diff --git a/buf.gen.yaml b/buf.gen.yaml index 656df4078..12b5ceeaf 100644 --- a/buf.gen.yaml +++ b/buf.gen.yaml @@ -6,3 +6,15 @@ plugins: - remote: buf.build/grpc/go:v1.5.1 out: . opt: paths=source_relative + - remote: buf.build/community/planetscale-vtprotobuf + out: . + opt: + - paths=source_relative + - features=marshal+unmarshal+size+pool + - pool=github.com/ethpandaops/xatu/pkg/proto/xatu.* + - pool=github.com/ethpandaops/xatu/pkg/proto/eth/v1.* + - pool=github.com/ethpandaops/xatu/pkg/proto/eth/v2.* + - pool=github.com/ethpandaops/xatu/pkg/proto/libp2p.* + - pool=github.com/ethpandaops/xatu/pkg/proto/libp2p/gossipsub.* + - pool=github.com/ethpandaops/xatu/pkg/proto/mevrelay.* + - pool=github.com/ethpandaops/xatu/pkg/proto/noderecord.* diff --git a/deploy/local/docker-compose/grafana/dashboards/xatu/consumoor.json b/deploy/local/docker-compose/grafana/dashboards/xatu/consumoor.json index 9fd861ad4..3c3ed6df5 100644 --- a/deploy/local/docker-compose/grafana/dashboards/xatu/consumoor.json +++ b/deploy/local/docker-compose/grafana/dashboards/xatu/consumoor.json @@ -48,7 +48,7 @@ }, "overrides": [] }, - "gridPos": { "h": 4, "w": 6, "x": 0, "y": 1 }, + "gridPos": { "h": 4, "w": 5, "x": 0, "y": 1 }, "id": 1, "options": { "colorMode": "value", @@ -95,7 +95,7 @@ }, "overrides": [] }, - "gridPos": { "h": 4, "w": 6, "x": 6, "y": 1 }, + "gridPos": { "h": 4, "w": 5, "x": 5, "y": 1 }, "id": 2, "options": { "colorMode": "value", @@ -143,7 +143,7 @@ }, "overrides": [] }, - "gridPos": { "h": 4, "w": 6, "x": 12, "y": 1 }, + "gridPos": { "h": 4, "w": 5, "x": 10, "y": 1 }, "id": 3, "options": { "colorMode": "value", @@ -191,7 +191,7 @@ }, "overrides": [] }, - "gridPos": { "h": 4, "w": 6, "x": 18, "y": 1 }, + "gridPos": { "h": 4, "w": 5, "x": 15, "y": 1 }, "id": 4, "options": { "colorMode": "value", @@ -218,6 +218,52 @@ "title": "Total Consumer Lag", "type": "stat" }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { "mode": "thresholds" }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { "color": "green", "value": null } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { "h": 4, "w": 4, "x": 20, "y": 1 }, + "id": 5, + "options": { + "colorMode": "value", + "graphMode": "area", + "justifyMode": "auto", + "orientation": "auto", + "reduceOptions": { + "calcs": ["lastNotNull"], + "fields": "", + "values": false + }, + "textMode": "auto" + }, + "targets": [ + { + "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, + "editorMode": "code", + "expr": "xatu_consumoor_active_topics", + "legendFormat": "Active topics", + "range": true, + "refId": "A" + } + ], + "title": "Active Topics", + "type": "stat" + }, { "collapsed": false, "gridPos": { "h": 1, "w": 24, "x": 0, "y": 5 }, @@ -424,9 +470,75 @@ "title": "Decode Errors by Topic", "type": "timeseries" }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { "mode": "palette-classic" }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { "legend": false, "tooltip": false, "viz": false }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { "type": "linear" }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { "group": "A", "mode": "normal" }, + "thresholdsStyle": { "mode": "off" } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { "color": "green", "value": null } + ] + }, + "unit": "ops" + }, + "overrides": [] + }, + "gridPos": { "h": 8, "w": 24, "x": 0, "y": 14 }, + "id": 13, + "options": { + "legend": { + "calcs": ["lastNotNull"], + "displayMode": "table", + "placement": "bottom", + "showLegend": true, + "sortBy": "Last *", + "sortDesc": true + }, + "tooltip": { "mode": "multi", "sort": "desc" } + }, + "targets": [ + { + "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, + "editorMode": "code", + "expr": "sum by(topic, trigger) (rate(xatu_consumoor_batch_flush_trigger_total[$__rate_interval]))", + "legendFormat": "{{topic}} ({{trigger}})", + "range": true, + "refId": "A" + } + ], + "title": "Batch Flush Triggers", + "type": "timeseries" + }, { "collapsed": false, - "gridPos": { "h": 1, "w": 24, "x": 0, "y": 14 }, + "gridPos": { "h": 1, "w": 24, "x": 0, "y": 22 }, "id": 300, "title": "Routing", "type": "row" @@ -471,7 +583,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 0, "y": 15 }, + "gridPos": { "h": 8, "w": 8, "x": 0, "y": 23 }, "id": 20, "options": { "legend": { @@ -538,7 +650,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 8, "y": 15 }, + "gridPos": { "h": 8, "w": 8, "x": 8, "y": 23 }, "id": 21, "options": { "legend": { @@ -603,7 +715,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 16, "y": 15 }, + "gridPos": { "h": 8, "w": 8, "x": 16, "y": 23 }, "id": 22, "options": { "legend": { @@ -629,7 +741,90 @@ }, { "collapsed": false, - "gridPos": { "h": 1, "w": 24, "x": 0, "y": 23 }, + "gridPos": { "h": 1, "w": 24, "x": 0, "y": 31 }, + "id": 350, + "title": "Event Lag", + "type": "row" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { "mode": "palette-classic" }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { "legend": false, "tooltip": false, "viz": false }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { "type": "linear" }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { "group": "A", "mode": "none" }, + "thresholdsStyle": { "mode": "off" } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { "color": "green", "value": null }, + { "color": "orange", "value": 30 }, + { "color": "red", "value": 120 } + ] + }, + "unit": "s" + }, + "overrides": [] + }, + "gridPos": { "h": 8, "w": 24, "x": 0, "y": 32 }, + "id": 25, + "options": { + "legend": { + "calcs": ["lastNotNull"], + "displayMode": "table", + "placement": "bottom", + "showLegend": true, + "sortBy": "Last *", + "sortDesc": true + }, + "tooltip": { "mode": "multi", "sort": "desc" } + }, + "targets": [ + { + "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, + "editorMode": "code", + "expr": "histogram_quantile(0.50, sum by(event_name, le) (rate(xatu_consumoor_event_lag_seconds_bucket[$__rate_interval])))", + "legendFormat": "p50 {{event_name}}", + "range": true, + "refId": "A" + }, + { + "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, + "editorMode": "code", + "expr": "histogram_quantile(0.99, sum by(event_name, le) (rate(xatu_consumoor_event_lag_seconds_bucket[$__rate_interval])))", + "legendFormat": "p99 {{event_name}}", + "range": true, + "refId": "B" + } + ], + "title": "Event Lag (p50 / p99)", + "type": "timeseries" + }, + { + "collapsed": false, + "gridPos": { "h": 1, "w": 24, "x": 0, "y": 40 }, "id": 400, "title": "ClickHouse Writes", "type": "row" @@ -674,7 +869,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 0, "y": 24 }, + "gridPos": { "h": 8, "w": 6, "x": 0, "y": 41 }, "id": 30, "options": { "legend": { @@ -742,7 +937,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 8, "y": 24 }, + "gridPos": { "h": 8, "w": 6, "x": 6, "y": 41 }, "id": 31, "options": { "legend": { @@ -816,7 +1011,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 16, "y": 24 }, + "gridPos": { "h": 8, "w": 6, "x": 12, "y": 41 }, "id": 32, "options": { "legend": { @@ -842,9 +1037,77 @@ "title": "Avg Batch Size by Table", "type": "timeseries" }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { "mode": "palette-classic" }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { "legend": false, "tooltip": false, "viz": false }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { "type": "linear" }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { "group": "A", "mode": "none" }, + "thresholdsStyle": { "mode": "off" } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { "color": "green", "value": null }, + { "color": "orange", "value": 0.1 }, + { "color": "red", "value": 1 } + ] + }, + "unit": "ops" + }, + "overrides": [] + }, + "gridPos": { "h": 8, "w": 6, "x": 18, "y": 41 }, + "id": 33, + "options": { + "legend": { + "calcs": ["lastNotNull"], + "displayMode": "table", + "placement": "bottom", + "showLegend": true, + "sortBy": "Last *", + "sortDesc": true + }, + "tooltip": { "mode": "multi", "sort": "desc" } + }, + "targets": [ + { + "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, + "editorMode": "code", + "expr": "sum by(operation) (rate(xatu_consumoor_write_retries_total[$__rate_interval]))", + "legendFormat": "{{operation}}", + "range": true, + "refId": "A" + } + ], + "title": "Write Retries", + "type": "timeseries" + }, { "collapsed": false, - "gridPos": { "h": 1, "w": 24, "x": 0, "y": 32 }, + "gridPos": { "h": 1, "w": 24, "x": 0, "y": 49 }, "id": 500, "title": "Buffer & Backpressure", "type": "row" @@ -865,8 +1128,8 @@ "axisPlacement": "auto", "barAlignment": 0, "drawStyle": "line", - "fillOpacity": 20, - "gradientMode": "scheme", + "fillOpacity": 10, + "gradientMode": "none", "hideFrom": { "legend": false, "tooltip": false, "viz": false }, "insertNulls": false, "lineInterpolation": "linear", @@ -882,22 +1145,219 @@ "thresholds": { "mode": "absolute", "steps": [ - { "color": "green", "value": null }, - { "color": "orange", "value": 50000 }, - { "color": "red", "value": 100000 } + { "color": "green", "value": null } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { "h": 8, "w": 6, "x": 0, "y": 50 }, + "id": 41, + "options": { + "legend": { + "calcs": ["lastNotNull"], + "displayMode": "table", + "placement": "bottom", + "showLegend": true, + "sortBy": "Last *", + "sortDesc": true + }, + "tooltip": { "mode": "multi", "sort": "desc" } + }, + "targets": [ + { + "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, + "editorMode": "code", + "expr": "xatu_consumoor_adaptive_limiter_limit", + "legendFormat": "{{table}}", + "range": true, + "refId": "A" + } + ], + "title": "Adaptive Limiter Limit", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { "mode": "palette-classic" }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { "legend": false, "tooltip": false, "viz": false }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { "type": "linear" }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { "group": "A", "mode": "none" }, + "thresholdsStyle": { "mode": "off" } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { "color": "green", "value": null } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { "h": 8, "w": 6, "x": 6, "y": 50 }, + "id": 42, + "options": { + "legend": { + "calcs": ["lastNotNull"], + "displayMode": "table", + "placement": "bottom", + "showLegend": true, + "sortBy": "Last *", + "sortDesc": true + }, + "tooltip": { "mode": "multi", "sort": "desc" } + }, + "targets": [ + { + "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, + "editorMode": "code", + "expr": "xatu_consumoor_adaptive_limiter_inflight", + "legendFormat": "{{table}}", + "range": true, + "refId": "A" + } + ], + "title": "Adaptive Limiter In-Flight", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { "mode": "palette-classic" }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { "legend": false, "tooltip": false, "viz": false }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { "type": "linear" }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { "group": "A", "mode": "none" }, + "thresholdsStyle": { "mode": "off" } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { "color": "green", "value": null } ] }, "unit": "short" }, "overrides": [] }, - "gridPos": { "h": 8, "w": 24, "x": 0, "y": 33 }, - "id": 40, + "gridPos": { "h": 8, "w": 6, "x": 12, "y": 50 }, + "id": 43, "options": { "legend": { - "calcs": ["lastNotNull", "max"], + "calcs": ["lastNotNull"], "displayMode": "table", - "placement": "right", + "placement": "bottom", + "showLegend": true, + "sortBy": "Last *", + "sortDesc": true + }, + "tooltip": { "mode": "multi", "sort": "desc" } + }, + "targets": [ + { + "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, + "editorMode": "code", + "expr": "xatu_consumoor_adaptive_limiter_queued", + "legendFormat": "{{table}}", + "range": true, + "refId": "A" + } + ], + "title": "Adaptive Limiter Queued", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { "mode": "palette-classic" }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { "legend": false, "tooltip": false, "viz": false }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { "type": "linear" }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { "group": "A", "mode": "none" }, + "thresholdsStyle": { "mode": "off" } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { "color": "green", "value": null }, + { "color": "red", "value": 1 } + ] + }, + "unit": "ops" + }, + "overrides": [] + }, + "gridPos": { "h": 8, "w": 6, "x": 18, "y": 50 }, + "id": 44, + "options": { + "legend": { + "calcs": ["lastNotNull"], + "displayMode": "table", + "placement": "bottom", "showLegend": true, "sortBy": "Last *", "sortDesc": true @@ -908,18 +1368,18 @@ { "datasource": { "type": "prometheus", "uid": "PBFA97CFB590B2093" }, "editorMode": "code", - "expr": "xatu_consumoor_buffer_usage", + "expr": "sum by(table) (rate(xatu_consumoor_adaptive_limiter_rejections_total[$__rate_interval]))", "legendFormat": "{{table}}", "range": true, "refId": "A" } ], - "title": "Buffer Usage by Table", + "title": "Adaptive Limiter Rejections", "type": "timeseries" }, { "collapsed": false, - "gridPos": { "h": 1, "w": 24, "x": 0, "y": 41 }, + "gridPos": { "h": 1, "w": 24, "x": 0, "y": 58 }, "id": 600, "title": "Errors", "type": "row" @@ -965,7 +1425,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 6, "x": 0, "y": 42 }, + "gridPos": { "h": 8, "w": 6, "x": 0, "y": 59 }, "id": 50, "options": { "legend": { @@ -1030,7 +1490,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 6, "x": 6, "y": 42 }, + "gridPos": { "h": 8, "w": 6, "x": 6, "y": 59 }, "id": 51, "options": { "legend": { @@ -1095,7 +1555,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 6, "x": 12, "y": 42 }, + "gridPos": { "h": 8, "w": 6, "x": 12, "y": 59 }, "id": 52, "options": { "legend": { @@ -1160,7 +1620,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 6, "x": 18, "y": 42 }, + "gridPos": { "h": 8, "w": 6, "x": 18, "y": 59 }, "id": 53, "options": { "legend": { @@ -1186,7 +1646,7 @@ }, { "collapsed": false, - "gridPos": { "h": 1, "w": 24, "x": 0, "y": 50 }, + "gridPos": { "h": 1, "w": 24, "x": 0, "y": 67 }, "id": 700, "title": "Connection Pool (ch-go)", "type": "row" @@ -1231,7 +1691,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 0, "y": 51 }, + "gridPos": { "h": 8, "w": 8, "x": 0, "y": 68 }, "id": 60, "options": { "legend": { @@ -1327,7 +1787,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 8, "y": 51 }, + "gridPos": { "h": 8, "w": 8, "x": 8, "y": 68 }, "id": 61, "options": { "legend": { @@ -1399,7 +1859,7 @@ }, "overrides": [] }, - "gridPos": { "h": 8, "w": 8, "x": 16, "y": 51 }, + "gridPos": { "h": 8, "w": 8, "x": 16, "y": 68 }, "id": 62, "options": { "legend": { diff --git a/docs/consumoor-runbook.md b/docs/consumoor-runbook.md index 70afa2bc2..43984f402 100644 --- a/docs/consumoor-runbook.md +++ b/docs/consumoor-runbook.md @@ -10,7 +10,7 @@ Consumoor is a Kafka-to-ClickHouse pipeline that reads Ethereum network events f Kafka topics | v -Benthos (kafka_franz input) +Benthos (kafka_franz input, maxInFlight=64 concurrent WriteBatch calls) | v Decoder (JSON or Protobuf -> DecoratedEvent) @@ -22,17 +22,20 @@ Router Engine (event name -> target table(s)) Per-table buffer (bounded channel, one per table) | v -Table Writer (organic + coordinated flush) +FlushTables (concurrent drain + flush from calling goroutines) | v -ClickHouse (ch-go columnar inserts) +Adaptive Concurrency Limiter (per-table AIMD, blocking acquire) + | + v +ClickHouse (ch-go columnar inserts, concurrent per table) ``` **Key design decisions:** - **At-least-once delivery.** Kafka offsets are committed periodically (`commitInterval`, default 5s). On crash, messages since the last commit are replayed. ClickHouse must tolerate duplicate inserts (e.g. via `ReplacingMergeTree`). - **Per-topic consumer groups.** Each consumoor instance joins a single consumer group. Multiple instances with different consumer groups or topic patterns can run in parallel. -- **Organic vs coordinated flushes.** Each table writer flushes independently when its batch reaches `batchSize` rows or when `flushInterval` elapses (organic). The Benthos output plugin can also trigger a coordinated `FlushAll` after writing a batch of messages, depending on the `deliveryMode`. +- **Benthos-driven batching.** Benthos accumulates messages according to `outputBatchCount` and `outputBatchPeriod`, then calls `WriteBatch` which routes events to per-table buffers and triggers a synchronous flush. Up to `maxInFlight` (default 64) WriteBatch calls run concurrently, enabling concurrent INSERTs per table bounded by the adaptive concurrency limiter. There are no independent timer-based flushes -- all writes are coordinated through Benthos. - **Backpressure propagation.** Each table's buffer is a bounded channel (`bufferSize`). When a buffer fills (e.g. ClickHouse is slow), `Write()` blocks, which backs up the Benthos output, which backs up Kafka consumption. This prevents unbounded memory growth. - **Error classification.** Write errors are classified as permanent (schema mismatch, unknown table, type errors) or transient (network, timeout, overload). Permanent errors drop the batch and optionally send messages to a DLQ topic. Transient errors trigger retry with exponential backoff. @@ -58,8 +61,7 @@ All metrics use the prefix `xatu_consumoor_`. | `rows_written_total` | Counter | `table` | Rows successfully written to ClickHouse | Should increase; flat = writes stalled | | `write_errors_total` | Counter | `table` | ClickHouse write errors | Any increase; check permanent vs transient | | `write_duration_seconds` | Histogram | `table` | Duration of batch inserts | p99 > `queryTimeout` = ClickHouse too slow | -| `batch_size` | Histogram | `table` | Rows per batch write | Very small batches = inefficient; tune `batchSize` | -| `buffer_usage` | Gauge | `table` | Current buffered rows per table | Approaching `bufferSize` = backpressure building | +| `batch_size` | Histogram | `table` | Rows per batch write | Very small batches = inefficient; tune `outputBatchCount` | ### DLQ Metrics @@ -88,7 +90,6 @@ All metrics use the prefix `xatu_consumoor_`. ### ClickHouse Down or Slow **Symptoms:** -- `buffer_usage` climbing toward `bufferSize` for affected tables - `write_errors_total` increasing - `rows_written_total` flat - `write_duration_seconds` p99 increasing (if ClickHouse is slow but reachable) @@ -96,16 +97,14 @@ All metrics use the prefix `xatu_consumoor_`. **What happens internally:** 1. Table writer flush fails with a transient error (connection refused, timeout, etc.) -2. The table writer enters `flushBlocked` state -- it stops draining its buffer channel and preserves the failed batch for retry -3. Buffer channel fills up, blocking `Write()` calls -4. Benthos output blocks, causing Kafka fetch to stall -5. On next `flushInterval` tick, the table writer retries the pending batch (with exponential backoff via `doWithRetry`: default 3 retries, 100ms base delay, 2s max delay) -6. If retry succeeds, `flushBlocked` clears and normal processing resumes +2. `FlushTables` returns the error to `processGroup`, which NAKs the Kafka messages (they will be re-delivered by Kafka) +3. Each flush attempt uses exponential backoff via `doWithRetry` (default 3 retries, 100ms base delay, 2s max delay) +4. The buffer channel fills up, blocking `Write()` calls, which backs up Benthos output and stalls Kafka consumption **Recovery:** - Fix ClickHouse (restart, add capacity, resolve disk issues) - Consumoor auto-recovers once ClickHouse is available -- no restart needed -- Monitor `buffer_usage` dropping and `rows_written_total` resuming +- Monitor `rows_written_total` resuming - Expect a burst of writes as buffered data flushes ### Kafka Rebalance Storm @@ -130,27 +129,24 @@ All metrics use the prefix `xatu_consumoor_`. ### OOM / Memory Pressure **Symptoms:** -- `buffer_usage` high across multiple tables - Pod OOMKilled restarts - Memory usage on the node spiking **Causes:** - ClickHouse backpressure fills all table buffers simultaneously. Total potential memory = `bufferSize * number_of_active_tables * avg_event_size` - Very large `bufferSize` values combined with many tables -- Large batch sizes holding many events in memory during flush +- Large `outputBatchCount` holding many events in memory during flush **Mitigation:** - Reduce `bufferSize` in defaults (e.g. from 200000 to 50000) +- Reduce `outputBatchCount` to flush smaller batches - Increase ClickHouse write capacity (more replicas, faster disks) -- Tune `batchSize` down to flush more frequently with less memory per flush - Increase pod memory limits if the workload genuinely requires it -- Monitor `buffer_usage` across all tables to estimate actual memory use ### Flatten Livelock **Symptoms:** - One table's `rows_written_total` stops increasing -- `buffer_usage` for that table grows (or stays at max if already full) - `write_errors_total` for that table climbing - `flatten_errors_total` increasing for the affected event/table - Other tables continue writing normally @@ -175,16 +171,15 @@ All metrics use the prefix `xatu_consumoor_`. **Causes:** - ClickHouse write throughput is the bottleneck (check `write_duration_seconds`) -- Batch sizes too small causing excessive round-trips (check `batch_size` histogram) +- Batch sizes too small causing excessive round-trips (check `batch_size` histogram; increase `outputBatchCount`) - Single instance hitting connection pool limits (check `chgo_pool_empty_acquire_total`) - High-cardinality topics spreading events across many tables, each with its own flush cycle **Tuning:** -- Increase `batchSize` to write more rows per round-trip (e.g. 200000 -> 500000) +- Increase `outputBatchCount` to write more rows per round-trip (e.g. 1000 -> 5000) - Increase `maxConns` to allow more concurrent ClickHouse writes - Increase ClickHouse resources (CPU, memory, disk I/O) - Scale horizontally: run multiple consumoor instances with different topic patterns or consumer groups -- Switch from `deliveryMode: message` to `deliveryMode: batch` if not already (batch mode is significantly faster) ### DLQ Failures @@ -265,9 +260,9 @@ Common causes of startup failure: ### Vertical Scaling -- Increase `maxConns` to allow more concurrent ClickHouse writes (default: 8) -- Increase `batchSize` to write more rows per INSERT (default: 200000) -- Increase `bufferSize` to absorb more backpressure spikes (default: 200000), at the cost of higher memory usage +- Increase `maxConns` to allow more concurrent ClickHouse writes (default: 64) +- Increase `outputBatchCount` to write more rows per INSERT (default: 1000) +- Increase `bufferSize` to absorb more backpressure spikes (default: 50000), at the cost of higher memory usage - Increase pod CPU/memory to handle more concurrent table writers ## Configuration Tuning @@ -276,34 +271,33 @@ Common causes of startup failure: | Parameter | Path | Default | When to adjust | |-----------|------|---------|----------------| -| `batchSize` | `clickhouse.defaults.batchSize` | 200000 | Increase for higher throughput (more rows per INSERT); decrease to reduce memory per flush | -| `flushInterval` | `clickhouse.defaults.flushInterval` | 1s | Decrease for lower latency; increase if batches are too small | -| `bufferSize` | `clickhouse.defaults.bufferSize` | 200000 | Increase to absorb ClickHouse hiccups without backpressure; decrease to limit memory | +| `outputBatchCount` | `kafka.outputBatchCount` | 1000 | Increase for higher throughput (more rows per INSERT); decrease to reduce memory per flush | +| `outputBatchPeriod` | `kafka.outputBatchPeriod` | 1s | Decrease for lower latency; increase if batches are too small | +| `maxInFlight` | `kafka.maxInFlight` | 64 | Concurrent WriteBatch calls per stream; increase for more throughput, decrease if ClickHouse is overloaded | +| `bufferSize` | `clickhouse.defaults.bufferSize` | 50000 | Increase to absorb ClickHouse hiccups without backpressure; decrease to limit memory | | `commitInterval` | `kafka.commitInterval` | 5s | Decrease to reduce duplicate replay window on crash; increase to reduce Kafka commit overhead | -| `maxConns` | `clickhouse.chgo.maxConns` | 8 | Increase when `chgo_pool_empty_acquire_total` is high | +| `maxConns` | `clickhouse.chgo.maxConns` | 64 | Increase when `chgo_pool_empty_acquire_total` is high | | `queryTimeout` | `clickhouse.chgo.queryTimeout` | 30s | Increase if large batches legitimately take longer to insert | | `maxRetries` | `clickhouse.chgo.maxRetries` | 3 | Increase if transient ClickHouse errors are frequent but recover quickly | -| `deliveryMode` | `kafka.deliveryMode` | batch | Use `message` for safer per-message delivery; use `batch` for higher throughput | | `sessionTimeoutMs` | `kafka.sessionTimeoutMs` | 30000 | Increase if rebalances are frequent due to slow processing | +| `adaptiveLimiter.enabled` | `clickhouse.chgo.adaptiveLimiter.enabled` | true | Per-table AIMD concurrency limiting; disable if all tables have uniform latency | +| `adaptiveLimiter.initialLimit` | `clickhouse.chgo.adaptiveLimiter.initialLimit` | 8 | Starting concurrent INSERTs per table before adaptation | +| `adaptiveLimiter.maxLimit` | `clickhouse.chgo.adaptiveLimiter.maxLimit` | 50 | Upper bound on concurrent INSERTs per table | +| `topicOverrides` | `kafka.topicOverrides.` | (none) | Per-topic overrides for `outputBatchCount`, `outputBatchPeriod`, and `maxInFlight`; matched by exact topic name | | `tableSuffix` | `clickhouse.tableSuffix` | (empty) | Set to `_local` to bypass Distributed tables in clustered setups | ### Per-Table Overrides -High-volume tables (e.g. attestations, committees) may need larger batch and buffer sizes: +High-volume tables (e.g. attestations, committees) may need larger buffer sizes: ```yaml clickhouse: defaults: - batchSize: 200000 - bufferSize: 200000 - flushInterval: 1s + bufferSize: 50000 tables: beacon_api_eth_v1_events_attestation: - batchSize: 1000000 bufferSize: 1000000 - flushInterval: 5s beacon_api_eth_v1_beacon_committee: - batchSize: 1000000 bufferSize: 1000000 ``` diff --git a/example_consumoor.yaml b/example_consumoor.yaml index 79db76bef..a7ab3737c 100644 --- a/example_consumoor.yaml +++ b/example_consumoor.yaml @@ -12,14 +12,26 @@ kafka: # offsetDefault: earliest # fetchMinBytes: 1 # fetchWaitMaxMs: 500 - # maxPartitionFetchBytes: 10485760 + # maxPartitionFetchBytes: 3145728 + # fetchMaxBytes: 10485760 # sessionTimeoutMs: 30000 - # heartbeatIntervalMs: 3000 + # rebalanceTimeout: 15s # max time for members to rejoin during rebalance commitInterval: 5s # Kafka offset commit interval # shutdownTimeout: 30s # max wait for in-flight messages during graceful shutdown # lagPollInterval: 30s # consumer lag poll interval (0 to disable) # rejectedTopic: xatu-consumoor-rejected # topicRefreshInterval: 60s # How often to re-discover topics matching regex patterns (0 to disable) + # outputBatchCount: 1000 # messages per Benthos output batch (0 to disable) + # outputBatchPeriod: 1s # max wait before flushing partial batch + # maxInFlight: 64 # concurrent WriteBatch calls per stream (higher = more throughput) + # topicOverrides: # per-topic batch settings (exact topic name match) + # general-beacon-block: + # outputBatchCount: 100 + # outputBatchPeriod: 100ms + # maxInFlight: 4 + # general-beacon-attestation: + # outputBatchCount: 50000 + # outputBatchPeriod: 5s # tls: # enabled: false # caFile: /path/to/ca.pem @@ -33,8 +45,6 @@ kafka: clickhouse: dsn: "clickhouse://localhost:9000/default" - # organicRetryInitDelay: 1s # initial backoff when a table flush fails - # organicRetryMaxDelay: 30s # max backoff cap for organic retries # failOnMissingTables: true # set to false to downgrade missing table errors to warnings # tls: # enabled: false @@ -49,30 +59,26 @@ clickhouse: # maxRetries: 3 # retryBaseDelay: 100ms # retryMaxDelay: 2s - # maxConns: 8 + # maxConns: 64 # minConns: 1 # connMaxLifetime: 1h # connMaxIdleTime: 10m # healthCheckPeriod: 30s # poolMetricsInterval: 15s - # bufferWarningThreshold: 0.8 # log warning when any table buffer exceeds this fraction (0-1) - defaults: - batchSize: 200000 - flushInterval: 1s - bufferSize: 200000 - tables: + # adaptiveLimiter: + # enabled: true # per-table adaptive concurrency limiting (AIMD) + # minLimit: 1 # minimum concurrent INSERTs per table + # maxLimit: 50 # maximum concurrent INSERTs per table + # initialLimit: 8 # starting concurrency before adaptation + # queueInitialRejectionFactor: 2 + # queueMaxRejectionFactor: 3 + # tables: # Canonical tables default to insertSettings.insert_quorum: auto (majority). # Set insertSettings.insert_quorum explicitly to override that behavior. - beacon_api_eth_v1_beacon_committee: - batchSize: 1000000 - bufferSize: 1000000 - # insertSettings: - # insert_quorum: 2 - # insert_quorum_timeout: 60000 - beacon_api_eth_v1_events_attestation: - batchSize: 1000000 - flushInterval: 5s - bufferSize: 1000000 + # beacon_api_eth_v1_beacon_committee: + # insertSettings: + # insert_quorum: 2 + # insert_quorum_timeout: 60000 # canonical_beacon_block: # insertSettings: # insert_quorum: 3 diff --git a/go.mod b/go.mod index e18045b86..eb44716e1 100644 --- a/go.mod +++ b/go.mod @@ -21,6 +21,7 @@ require ( github.com/ethpandaops/beacon v0.65.0 github.com/ethpandaops/ethcore v0.0.0-20260112064422-e7fe02956738 github.com/ethpandaops/ethwallclock v0.4.0 + github.com/failsafe-go/failsafe-go v0.9.6 github.com/ferranbt/fastssz v1.0.0 github.com/go-co-op/gocron/v2 v2.16.6 github.com/golang/protobuf v1.5.4 @@ -83,7 +84,7 @@ require ( github.com/VictoriaMetrics/fastcache v1.13.0 // indirect github.com/benbjohnson/clock v1.3.5 // indirect github.com/beorn7/perks v1.0.1 // indirect - github.com/bits-and-blooms/bitset v1.24.0 // indirect + github.com/bits-and-blooms/bitset v1.24.4 // indirect github.com/btcsuite/btcd/btcec/v2 v2.3.5 // indirect github.com/cenkalti/backoff/v4 v4.3.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect @@ -155,6 +156,7 @@ require ( github.com/huin/goupnp v1.3.0 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/influxdata/go-syslog/v3 v3.0.0 // indirect + github.com/influxdata/tdigest v0.0.1 // indirect github.com/ipfs/go-cid v0.5.0 // indirect github.com/ipfs/go-log/v2 v2.8.0 // indirect github.com/itchyny/gojq v0.12.18 // indirect @@ -243,6 +245,7 @@ require ( github.com/pion/turn/v4 v4.0.2 // indirect github.com/pion/webrtc/v4 v4.1.2 // indirect github.com/pk910/dynamic-ssz v0.0.6 // indirect + github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect github.com/prometheus/common v0.67.1 // indirect diff --git a/go.sum b/go.sum index ed044eee2..45ce7e56b 100644 --- a/go.sum +++ b/go.sum @@ -63,8 +63,8 @@ github.com/benbjohnson/clock v1.3.5 h1:VvXlSJBzZpA/zum6Sj74hxwYI2DIxRWuNIoXAzHZz github.com/benbjohnson/clock v1.3.5/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bits-and-blooms/bitset v1.24.0 h1:H4x4TuulnokZKvHLfzVRTHJfFfnHEeSYJizujEZvmAM= -github.com/bits-and-blooms/bitset v1.24.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/bits-and-blooms/bitset v1.24.4 h1:95H15Og1clikBrKr/DuzMXkQzECs1M6hhoGXLwLQOZE= +github.com/bits-and-blooms/bitset v1.24.4/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= @@ -193,6 +193,8 @@ github.com/ethpandaops/ethereum-package-go v0.8.0 h1:h4hyCTBgW+fWNxLLLP29GAhk0BM github.com/ethpandaops/ethereum-package-go v0.8.0/go.mod h1:LQThCwlCeeNBTdXOFV+xSwudoced53x+o/Orya3Y+oo= github.com/ethpandaops/ethwallclock v0.4.0 h1:+sgnhf4pk6hLPukP076VxkiLloE4L0Yk1yat+ZyHh1g= github.com/ethpandaops/ethwallclock v0.4.0/go.mod h1:y0Cu+mhGLlem19vnAV2x0hpFS5KZ7oOi2SWYayv9l24= +github.com/failsafe-go/failsafe-go v0.9.6 h1:vPSH2cry0Ee5cnR9wc9qshCDO6jdrMA9elBJNwyo4Uk= +github.com/failsafe-go/failsafe-go v0.9.6/go.mod h1:IeRpglkcwzKagjDMh90ZhN2l4Ovt3+jemQBUbThag54= github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= @@ -353,6 +355,8 @@ github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/influxdata/go-syslog/v3 v3.0.0 h1:jichmjSZlYK0VMmlz+k4WeOQd7z745YLsvGMqwtYt4I= github.com/influxdata/go-syslog/v3 v3.0.0/go.mod h1:tulsOp+CecTAYC27u9miMgq21GqXRW6VdKbOG+QSP4Q= +github.com/influxdata/tdigest v0.0.1 h1:XpFptwYmnEKUqmkcDjrzffswZ3nvNeevbUSLPP/ZzIY= +github.com/influxdata/tdigest v0.0.1/go.mod h1:Z0kXnxzbTC2qrx4NaIzYkE1k66+6oEDQTvL95hQFh5Y= github.com/ipfs/go-cid v0.5.0 h1:goEKKhaGm0ul11IHA7I6p1GmKz8kEYniqFopaB5Otwg= github.com/ipfs/go-cid v0.5.0/go.mod h1:0L7vmeNXpQpUS9vt+yEARkJ8rOg43DF3iPgn4GIN0mk= github.com/ipfs/go-log/v2 v2.8.0 h1:SptNTPJQV3s5EF4FdrTu/yVdOKfGbDgn1EBZx4til2o= @@ -651,6 +655,8 @@ github.com/pk910/dynamic-ssz v0.0.6/go.mod h1:b6CrLaB2X7pYA+OSEEbkgXDEcRnjLOZIxZ github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= @@ -878,6 +884,7 @@ golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98y golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8= golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A= +golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9 h1:TQwNpfvNkxAVlItJf6Cr5JTsVZoC/Sj7K3OZv2Pc14A= golang.org/x/exp v0.0.0-20251002181428-27f1f14c8bb9/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= @@ -977,6 +984,7 @@ golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE= golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8= golang.org/x/time v0.13.0 h1:eUlYslOIt32DgYD6utsuUeHs4d7AsEYLuIAdg7FlYgI= golang.org/x/time v0.13.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4= +golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 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= @@ -991,8 +999,10 @@ golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8T 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= golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +gonum.org/v1/gonum v0.0.0-20181121035319-3f7ecaa7e8ca/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk= gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E= +gonum.org/v1/netlib v0.0.0-20181029234149-ec6d1f5cefe6/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= google.golang.org/genproto/googleapis/api v0.0.0-20260128011058-8636f8732409 h1:merA0rdPeUV3YIIfHHcH4qBkiQAc1nfCKSI7lB4cV2M= google.golang.org/genproto/googleapis/api v0.0.0-20260128011058-8636f8732409/go.mod h1:fl8J1IvUjCilwZzQowmw2b7HQB2eAuYBabMXzWurF+I= google.golang.org/genproto/googleapis/rpc v0.0.0-20260128011058-8636f8732409 h1:H86B94AW+VfJWDqFeEbBPhEtHzJwJfTbgE2lZa54ZAQ= diff --git a/pkg/consumoor/clickhouse/adaptive_limiter.go b/pkg/consumoor/clickhouse/adaptive_limiter.go new file mode 100644 index 000000000..24b4aec79 --- /dev/null +++ b/pkg/consumoor/clickhouse/adaptive_limiter.go @@ -0,0 +1,78 @@ +package clickhouse + +import ( + "context" + + "github.com/failsafe-go/failsafe-go/adaptivelimiter" +) + +// adaptiveConcurrencyLimiter wraps failsafe-go's AdaptiveLimiter to provide +// per-table AIMD-based concurrency control around ClickHouse INSERTs. +type adaptiveConcurrencyLimiter struct { + limiter adaptivelimiter.AdaptiveLimiter[any] +} + +// newAdaptiveConcurrencyLimiter creates a limiter from config. Returns nil +// when disabled, which callers treat as a no-op passthrough. +func newAdaptiveConcurrencyLimiter( + cfg AdaptiveLimiterConfig, +) *adaptiveConcurrencyLimiter { + if !cfg.Enabled { + return nil + } + + builder := adaptivelimiter.NewBuilder[any](). + WithLimits(cfg.MinLimit, cfg.MaxLimit, cfg.InitialLimit) + + if cfg.QueueInitialRejectionFactor > 0 && cfg.QueueMaxRejectionFactor > 0 { + builder = builder.WithQueueing( + cfg.QueueInitialRejectionFactor, + cfg.QueueMaxRejectionFactor, + ) + } + + return &adaptiveConcurrencyLimiter{ + limiter: builder.Build(), + } +} + +// Limit returns the current concurrency limit. +func (l *adaptiveConcurrencyLimiter) Limit() int { + return l.limiter.Limit() +} + +// Inflight returns the number of in-flight permits. +func (l *adaptiveConcurrencyLimiter) Inflight() int { + return l.limiter.Inflight() +} + +// Queued returns the number of queued permit requests. +func (l *adaptiveConcurrencyLimiter) Queued() int { + return l.limiter.Queued() +} + +// doWithLimiter acquires a permit (blocking until one is available or ctx +// is cancelled), executes fn, and records the outcome. +// On success the permit is recorded (RTT measured); on failure the permit +// is dropped (signals the limiter to decrease concurrency). +// Returns limiterRejectedError if the limiter rejects the request. +func (l *adaptiveConcurrencyLimiter) doWithLimiter( + ctx context.Context, + fn func(context.Context) error, +) error { + permit, err := l.limiter.AcquirePermit(ctx) + if err != nil { + return &limiterRejectedError{cause: err} + } + + err = fn(ctx) + if err != nil { + permit.Drop() + + return err + } + + permit.Record() + + return nil +} diff --git a/pkg/consumoor/clickhouse/adaptive_limiter_test.go b/pkg/consumoor/clickhouse/adaptive_limiter_test.go new file mode 100644 index 000000000..3d9353166 --- /dev/null +++ b/pkg/consumoor/clickhouse/adaptive_limiter_test.go @@ -0,0 +1,112 @@ +package clickhouse + +import ( + "context" + "errors" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestNewAdaptiveConcurrencyLimiter_DisabledReturnsNil(t *testing.T) { + limiter := newAdaptiveConcurrencyLimiter(AdaptiveLimiterConfig{ + Enabled: false, + }) + + assert.Nil(t, limiter) +} + +func TestNewAdaptiveConcurrencyLimiter_EnabledReturnsLimiter(t *testing.T) { + limiter := newAdaptiveConcurrencyLimiter(AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 50, + InitialLimit: 8, + QueueInitialRejectionFactor: 2, + QueueMaxRejectionFactor: 3, + }) + + require.NotNil(t, limiter) + assert.Equal(t, 8, limiter.Limit()) + assert.Equal(t, 0, limiter.Inflight()) + assert.Equal(t, 0, limiter.Queued()) +} + +func TestAdaptiveConcurrencyLimiter_AcquireAndRecord(t *testing.T) { + limiter := newAdaptiveConcurrencyLimiter(AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 50, + InitialLimit: 8, + }) + + require.NotNil(t, limiter) + + err := limiter.doWithLimiter(context.Background(), func(_ context.Context) error { + // While in-flight, inflight should be >= 1. + assert.GreaterOrEqual(t, limiter.Inflight(), 1) + + return nil + }) + + require.NoError(t, err) +} + +func TestAdaptiveConcurrencyLimiter_AcquireAndDropOnError(t *testing.T) { + limiter := newAdaptiveConcurrencyLimiter(AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 50, + InitialLimit: 8, + }) + + require.NotNil(t, limiter) + + sentinel := errors.New("simulated failure") + + err := limiter.doWithLimiter(context.Background(), func(_ context.Context) error { + return sentinel + }) + + require.ErrorIs(t, err, sentinel) + // After drop, inflight should return to 0. + assert.Equal(t, 0, limiter.Inflight()) +} + +func TestAdaptiveConcurrencyLimiter_BlocksWhenFullAndCancels(t *testing.T) { + // Create a limiter with limit=1 so we can saturate it. + limiter := newAdaptiveConcurrencyLimiter(AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 1, + InitialLimit: 1, + }) + + require.NotNil(t, limiter) + + // Acquire the single permit. + permit, ok := limiter.limiter.TryAcquirePermit() + require.True(t, ok, "should acquire the single permit") + + // Second attempt should block and then fail when context is cancelled. + ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond) + defer cancel() + + err := limiter.doWithLimiter(ctx, func(_ context.Context) error { + return nil + }) + + require.Error(t, err) + assert.True(t, IsLimiterRejected(err)) + + // Release and verify we can acquire again. + permit.Record() + + err = limiter.doWithLimiter(context.Background(), func(_ context.Context) error { + return nil + }) + + require.NoError(t, err) +} diff --git a/pkg/consumoor/clickhouse/config.go b/pkg/consumoor/clickhouse/config.go index 75ae82969..73e0b4723 100644 --- a/pkg/consumoor/clickhouse/config.go +++ b/pkg/consumoor/clickhouse/config.go @@ -25,30 +25,13 @@ type Config struct { // directly to ReplicatedMergeTree tables in a clustered setup. TableSuffix string `yaml:"tableSuffix"` - // OrganicRetryInitDelay is the initial backoff delay when a table writer - // flush fails and the batch is preserved for retry on the next cycle. - OrganicRetryInitDelay time.Duration `yaml:"organicRetryInitDelay" default:"1s"` - // OrganicRetryMaxDelay caps the exponential backoff for organic retries. - OrganicRetryMaxDelay time.Duration `yaml:"organicRetryMaxDelay" default:"30s"` - // FailOnMissingTables controls whether missing ClickHouse tables cause // a fatal startup error. When true (default), startup is aborted if any // registered route table does not exist in the target database. Set to // false to downgrade to warnings and allow startup to proceed. FailOnMissingTables bool `yaml:"failOnMissingTables" default:"true"` - // DrainTimeout bounds how long each table writer waits for its final - // flush during shutdown. If ClickHouse is unresponsive the drain is - // cancelled after this duration rather than hanging indefinitely. - DrainTimeout time.Duration `yaml:"drainTimeout" default:"30s"` - - // BufferWarningThreshold is the fraction (0-1) of a table's bufferSize - // at which a rate-limited warning is logged. Provides early visibility - // into memory pressure before full backpressure kicks in. - // Default: 0.8 - BufferWarningThreshold float64 `yaml:"bufferWarningThreshold" default:"0.8"` - - // Defaults are the default batch settings for all tables. + // Defaults are the default table settings. Defaults TableConfig `yaml:"defaults"` // Tables contains per-table overrides for batch settings. @@ -58,14 +41,8 @@ type Config struct { ChGo ChGoConfig `yaml:"chgo"` } -// TableConfig holds batching parameters for a ClickHouse table. +// TableConfig holds per-table settings for the ClickHouse writer. type TableConfig struct { - // BatchSize is the maximum number of rows per batch insert. - BatchSize int `yaml:"batchSize" default:"200000"` - // FlushInterval is the maximum time between flushes. - FlushInterval time.Duration `yaml:"flushInterval" default:"1s"` - // BufferSize is the channel buffer capacity for pending rows. - BufferSize int `yaml:"bufferSize" default:"200000"` // SkipFlattenErrors when true skips events that fail FlattenTo // instead of failing the entire batch. Default false = fail-fast. SkipFlattenErrors bool `yaml:"skipFlattenErrors"` @@ -79,6 +56,67 @@ type TableConfig struct { InsertSettings map[string]any `yaml:"insertSettings"` } +// AdaptiveLimiterConfig configures per-table adaptive concurrency limiting. +// When enabled, each table writer independently adjusts its INSERT concurrency +// based on observed ClickHouse latency using an AIMD algorithm. +type AdaptiveLimiterConfig struct { + // Enabled turns on adaptive concurrency limiting. + Enabled bool `yaml:"enabled" default:"true"` + // MinLimit is the minimum concurrent INSERTs the limiter allows. + MinLimit uint `yaml:"minLimit" default:"1"` + // MaxLimit caps the maximum concurrent INSERTs the limiter allows. + MaxLimit uint `yaml:"maxLimit" default:"50"` + // InitialLimit is the starting concurrency before adaptation. + InitialLimit uint `yaml:"initialLimit" default:"8"` + // QueueInitialRejectionFactor controls the queue size below which + // requests are rejected during the initial learning phase. + QueueInitialRejectionFactor float64 `yaml:"queueInitialRejectionFactor" default:"2"` + // QueueMaxRejectionFactor controls the queue size below which + // requests are rejected after the initial learning phase. + QueueMaxRejectionFactor float64 `yaml:"queueMaxRejectionFactor" default:"3"` +} + +// Validate checks the adaptive limiter configuration for errors. +func (c *AdaptiveLimiterConfig) Validate() error { + if !c.Enabled { + return nil + } + + if c.MinLimit == 0 { + return errors.New("clickhouse.chgo.adaptiveLimiter: minLimit must be > 0") + } + + if c.MaxLimit == 0 { + return errors.New("clickhouse.chgo.adaptiveLimiter: maxLimit must be > 0") + } + + if c.MinLimit > c.MaxLimit { + return errors.New( + "clickhouse.chgo.adaptiveLimiter: minLimit must be <= maxLimit", + ) + } + + if c.InitialLimit < c.MinLimit || c.InitialLimit > c.MaxLimit { + return errors.New( + "clickhouse.chgo.adaptiveLimiter: initialLimit must be between minLimit and maxLimit", + ) + } + + if c.QueueInitialRejectionFactor <= 0 { + return errors.New( + "clickhouse.chgo.adaptiveLimiter: queueInitialRejectionFactor must be > 0", + ) + } + + if c.QueueMaxRejectionFactor <= 0 { + return errors.New( + "clickhouse.chgo.adaptiveLimiter: queueMaxRejectionFactor must be > 0", + ) + } + + return nil +} + // ChGoConfig configures the ch-go backend query retries and connection pooling. type ChGoConfig struct { // DialTimeout is the timeout for establishing a connection to ClickHouse. @@ -98,7 +136,7 @@ type ChGoConfig struct { RetryMaxDelay time.Duration `yaml:"retryMaxDelay" default:"2s"` // MaxConns is the maximum number of pooled ClickHouse connections. - MaxConns int32 `yaml:"maxConns" default:"8"` + MaxConns int32 `yaml:"maxConns" default:"64"` // MinConns is the minimum number of pooled ClickHouse connections. MinConns int32 `yaml:"minConns" default:"1"` // ConnMaxLifetime is the maximum lifetime for pooled connections. @@ -111,6 +149,19 @@ type ChGoConfig struct { // PoolMetricsInterval controls how often pool stats are sampled. // Set to 0 to disable pool metrics collection. PoolMetricsInterval time.Duration `yaml:"poolMetricsInterval" default:"15s"` + + // GroupRetryMaxAttempts is the number of retry attempts at the + // processGroup level for partial table failures (e.g. fanout where + // some tables succeed and others fail transiently). Only failed tables + // are retried, preventing duplicate writes to already-succeeded tables. + GroupRetryMaxAttempts int `yaml:"groupRetryMaxAttempts" default:"3"` + // GroupRetryBaseDelay is the initial delay before the first group retry. + GroupRetryBaseDelay time.Duration `yaml:"groupRetryBaseDelay" default:"1s"` + // GroupRetryMaxDelay caps exponential backoff for group retries. + GroupRetryMaxDelay time.Duration `yaml:"groupRetryMaxDelay" default:"30s"` + + // AdaptiveLimiter configures per-table adaptive concurrency limiting. + AdaptiveLimiter AdaptiveLimiterConfig `yaml:"adaptiveLimiter"` } // Validate checks the ClickHouse configuration for errors. @@ -123,65 +174,15 @@ func (c *Config) Validate() error { return fmt.Errorf("clickhouse.%w", err) } - if c.OrganicRetryInitDelay <= 0 { - return errors.New("clickhouse: organicRetryInitDelay must be > 0") - } - - if c.OrganicRetryMaxDelay <= 0 { - return errors.New("clickhouse: organicRetryMaxDelay must be > 0") - } - - if c.OrganicRetryInitDelay > c.OrganicRetryMaxDelay { - return errors.New( - "clickhouse: organicRetryInitDelay must be <= organicRetryMaxDelay", - ) - } - if err := c.ChGo.Validate(); err != nil { return err } - if c.DrainTimeout <= 0 { - return errors.New("clickhouse: drainTimeout must be > 0") - } - - if c.BufferWarningThreshold < 0 || c.BufferWarningThreshold > 1 { - return errors.New("clickhouse: bufferWarningThreshold must be between 0 and 1") - } - - if c.Defaults.BatchSize <= 0 { - return errors.New("clickhouse.defaults: batchSize must be > 0") - } - - if c.Defaults.FlushInterval <= 0 { - return errors.New("clickhouse.defaults: flushInterval must be > 0") - } - - if c.Defaults.BufferSize <= 0 { - return errors.New("clickhouse.defaults: bufferSize must be > 0") - } - - if c.Defaults.BufferSize < c.Defaults.BatchSize { - return errors.New("clickhouse.defaults: bufferSize must be >= batchSize") - } - if err := validateInsertSettings(c.Defaults.InsertSettings, "clickhouse.defaults.insertSettings"); err != nil { return err } for table, override := range c.Tables { - if override.BatchSize < 0 { - return fmt.Errorf("clickhouse.tables.%s: batchSize must be >= 0", table) - } - - if override.FlushInterval < 0 { - return fmt.Errorf("clickhouse.tables.%s: flushInterval must be >= 0", table) - } - - if override.BufferSize < 0 { - return fmt.Errorf("clickhouse.tables.%s: bufferSize must be >= 0", table) - } - path := fmt.Sprintf("clickhouse.tables.%s.insertSettings", table) if err := validateInsertSettings(override.InsertSettings, path); err != nil { return err @@ -245,6 +246,22 @@ func (c *ChGoConfig) Validate() error { return errors.New("clickhouse.chgo: poolMetricsInterval must be >= 0") } + if c.GroupRetryMaxAttempts < 0 { + return errors.New("clickhouse.chgo: groupRetryMaxAttempts must be >= 0") + } + + if c.GroupRetryBaseDelay < 0 { + return errors.New("clickhouse.chgo: groupRetryBaseDelay must be >= 0") + } + + if c.GroupRetryMaxDelay < 0 { + return errors.New("clickhouse.chgo: groupRetryMaxDelay must be >= 0") + } + + if err := c.AdaptiveLimiter.Validate(); err != nil { + return err + } + return nil } @@ -261,18 +278,6 @@ func (c *Config) TableConfigFor(table string) TableConfig { return cfg } - if override.BatchSize > 0 { - cfg.BatchSize = override.BatchSize - } - - if override.FlushInterval > 0 { - cfg.FlushInterval = override.FlushInterval - } - - if override.BufferSize > 0 { - cfg.BufferSize = override.BufferSize - } - cfg.SkipFlattenErrors = cfg.SkipFlattenErrors || override.SkipFlattenErrors if len(override.InsertSettings) > 0 { diff --git a/pkg/consumoor/clickhouse/config_test.go b/pkg/consumoor/clickhouse/config_test.go index 5a1a9e0b8..f6ead62b2 100644 --- a/pkg/consumoor/clickhouse/config_test.go +++ b/pkg/consumoor/clickhouse/config_test.go @@ -8,21 +8,6 @@ import ( "github.com/stretchr/testify/require" ) -func validConfig() Config { - return Config{ - DSN: "clickhouse://localhost:9000/default", - OrganicRetryInitDelay: 1 * time.Second, - OrganicRetryMaxDelay: 30 * time.Second, - DrainTimeout: 30 * time.Second, - Defaults: TableConfig{ - BatchSize: 200000, - FlushInterval: 1 * time.Second, - BufferSize: 200000, - }, - ChGo: validChGoConfig(), - } -} - func validChGoConfig() ChGoConfig { return ChGoConfig{ DialTimeout: 5 * time.Second, @@ -31,12 +16,20 @@ func validChGoConfig() ChGoConfig { MaxRetries: 3, RetryBaseDelay: 100 * time.Millisecond, RetryMaxDelay: 2 * time.Second, - MaxConns: 8, + MaxConns: 64, MinConns: 1, ConnMaxLifetime: 1 * time.Hour, ConnMaxIdleTime: 10 * time.Minute, HealthCheckPeriod: 30 * time.Second, PoolMetricsInterval: 15 * time.Second, + AdaptiveLimiter: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 50, + InitialLimit: 8, + QueueInitialRejectionFactor: 2, + QueueMaxRejectionFactor: 3, + }, } } @@ -116,56 +109,106 @@ func TestChGoConfig_Validate_ReadTimeout(t *testing.T) { } } -func TestConfig_Validate_OrganicRetry(t *testing.T) { +func TestAdaptiveLimiterConfig_Validate(t *testing.T) { tests := []struct { - name string - initDelay time.Duration - maxDelay time.Duration - wantErr string + name string + cfg AdaptiveLimiterConfig + wantErr string }{ { - name: "valid", - initDelay: 1 * time.Second, - maxDelay: 30 * time.Second, + name: "disabled passes", + cfg: AdaptiveLimiterConfig{Enabled: false}, + }, + { + name: "valid enabled", + cfg: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 50, + InitialLimit: 8, + QueueInitialRejectionFactor: 2, + QueueMaxRejectionFactor: 3, + }, }, { - name: "equal init and max", - initDelay: 5 * time.Second, - maxDelay: 5 * time.Second, + name: "zero minLimit", + cfg: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 0, + MaxLimit: 50, + InitialLimit: 8, + }, + wantErr: "minLimit must be > 0", }, { - name: "zero init delay", - initDelay: 0, - maxDelay: 30 * time.Second, - wantErr: "organicRetryInitDelay must be > 0", + name: "zero maxLimit", + cfg: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 0, + InitialLimit: 1, + }, + wantErr: "maxLimit must be > 0", }, { - name: "negative init delay", - initDelay: -1 * time.Second, - maxDelay: 30 * time.Second, - wantErr: "organicRetryInitDelay must be > 0", + name: "minLimit exceeds maxLimit", + cfg: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 10, + MaxLimit: 5, + InitialLimit: 5, + }, + wantErr: "minLimit must be <= maxLimit", }, { - name: "zero max delay", - initDelay: 1 * time.Second, - maxDelay: 0, - wantErr: "organicRetryMaxDelay must be > 0", + name: "initialLimit below minLimit", + cfg: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 5, + MaxLimit: 50, + InitialLimit: 2, + }, + wantErr: "initialLimit must be between minLimit and maxLimit", }, { - name: "init exceeds max", - initDelay: 30 * time.Second, - maxDelay: 1 * time.Second, - wantErr: "organicRetryInitDelay must be <= organicRetryMaxDelay", + name: "initialLimit above maxLimit", + cfg: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 10, + InitialLimit: 20, + }, + wantErr: "initialLimit must be between minLimit and maxLimit", + }, + { + name: "zero queueInitialRejectionFactor", + cfg: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 50, + InitialLimit: 8, + QueueInitialRejectionFactor: 0, + QueueMaxRejectionFactor: 3, + }, + wantErr: "queueInitialRejectionFactor must be > 0", + }, + { + name: "zero queueMaxRejectionFactor", + cfg: AdaptiveLimiterConfig{ + Enabled: true, + MinLimit: 1, + MaxLimit: 50, + InitialLimit: 8, + QueueInitialRejectionFactor: 2, + QueueMaxRejectionFactor: 0, + }, + wantErr: "queueMaxRejectionFactor must be > 0", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - cfg := validConfig() - cfg.OrganicRetryInitDelay = tt.initDelay - cfg.OrganicRetryMaxDelay = tt.maxDelay - - err := cfg.Validate() + err := tt.cfg.Validate() if tt.wantErr != "" { require.Error(t, err) assert.Contains(t, err.Error(), tt.wantErr) diff --git a/pkg/consumoor/clickhouse/errors.go b/pkg/consumoor/clickhouse/errors.go index 2c6bd71aa..c64d5540f 100644 --- a/pkg/consumoor/clickhouse/errors.go +++ b/pkg/consumoor/clickhouse/errors.go @@ -36,8 +36,8 @@ type inputPrepError struct { func (e *inputPrepError) Error() string { return e.cause.Error() } func (e *inputPrepError) Unwrap() error { return e.cause } -// flattenError wraps FlattenTo failures. Not matched by IsPermanentWriteError, -// so the source nack path retries via Kafka redelivery. +// flattenError wraps FlattenTo failures. Classified as permanent because +// corrupt data cannot fix itself on retry. type flattenError struct { cause error } @@ -45,47 +45,106 @@ type flattenError struct { func (e *flattenError) Error() string { return fmt.Sprintf("flatten failed: %v", e.cause) } func (e *flattenError) Unwrap() error { return e.cause } +// limiterRejectedError indicates the adaptive concurrency limiter rejected +// the request. This is not retryable (doWithRetry exits immediately) and not +// permanent — the table writer simply waits for the next flush cycle. +type limiterRejectedError struct { + cause error +} + +func (e *limiterRejectedError) Error() string { + return fmt.Sprintf("adaptive limiter rejected: %v", e.cause) +} + +func (e *limiterRejectedError) Unwrap() error { return e.cause } + +// IsLimiterRejected reports whether err was caused by adaptive concurrency +// limiter rejection. +func IsLimiterRejected(err error) bool { + var lre *limiterRejectedError + + return errors.As(err, &lre) +} + // IsPermanentWriteError returns true for errors that will never succeed on -// retry: schema mismatches, type errors, conversion failures. +// retry: data-quality problems (bad values, parse failures) and code bugs +// (syntax errors, bad arguments). Schema mismatches (unknown table, missing +// column, column count) are intentionally excluded because they can be +// transient during rolling deployments when migrations haven't been applied +// yet — NAK + Kafka redelivery lets them self-resolve. +// +// For joined errors (from multi-table concurrent flushes), all constituent +// errors must be permanent for the result to be permanent. A single transient +// failure in any table means the group should be NAK'd for retry. func IsPermanentWriteError(err error) bool { if err == nil { return false } - var prepErr *inputPrepError - if errors.As(err, &prepErr) { + // Direct type checks — avoid errors.As which traverses into joined + // error children and would incorrectly match a single permanent child + // inside a mixed joined error. + switch e := err.(type) { + case *inputPrepError: return true + case *flattenError: + return true + case *ch.Exception: + return isPermanentCHException(e) } - if exc, ok := ch.AsException(err); ok { - return exc.IsCode( - proto.ErrUnknownTable, - proto.ErrUnknownDatabase, - proto.ErrNoSuchColumnInTable, - proto.ErrThereIsNoColumn, - proto.ErrUnknownIdentifier, - proto.ErrTypeMismatch, - proto.ErrCannotConvertType, - proto.ErrCannotParseText, - proto.ErrCannotParseNumber, - proto.ErrCannotParseDate, - proto.ErrCannotParseDatetime, - proto.ErrCannotInsertNullInOrdinaryColumn, - proto.ErrIncorrectData, - proto.ErrValueIsOutOfRangeOfDataType, - proto.ErrIncorrectNumberOfColumns, - proto.ErrNumberOfColumnsDoesntMatch, - proto.ErrIllegalColumn, - proto.ErrIllegalTypeOfArgument, - proto.ErrUnknownSetting, - proto.ErrBadArguments, - proto.ErrSyntaxError, - ) + // Multi-unwrap (errors.Join, ch.Exception chains): only permanent if + // ALL non-nil constituents are individually permanent. A single + // transient failure in any table means the group should be NAK'd. + if joined, ok := err.(interface{ Unwrap() []error }); ok { + errs := joined.Unwrap() + + hasConcrete := false + + for _, e := range errs { + if e == nil { + continue + } + + hasConcrete = true + + if !IsPermanentWriteError(e) { + return false + } + } + + return hasConcrete + } + + // Single-unwrap: walk the error chain (e.g. tableWriteError wrapping + // an inputPrepError or ch.Exception). + if unwrapper, ok := err.(interface{ Unwrap() error }); ok { + return IsPermanentWriteError(unwrapper.Unwrap()) } return false } +func isPermanentCHException(exc *ch.Exception) bool { + return exc.IsCode( + // Data-quality errors: the message payload itself is invalid, + // retrying the same data will never succeed. + proto.ErrCannotConvertType, + proto.ErrCannotParseText, + proto.ErrCannotParseNumber, + proto.ErrCannotParseDate, + proto.ErrCannotParseDatetime, + proto.ErrCannotInsertNullInOrdinaryColumn, + proto.ErrIncorrectData, + proto.ErrValueIsOutOfRangeOfDataType, + proto.ErrIllegalTypeOfArgument, + // Code/config bugs: no amount of retry will fix these. + proto.ErrUnknownSetting, + proto.ErrBadArguments, + proto.ErrSyntaxError, + ) +} + func isRetryableError(err error) bool { if err == nil { return false @@ -134,11 +193,14 @@ func isRetryableError(err error) bool { errStr := strings.ToLower(err.Error()) transientPatterns := []string{ - "connection reset", + "connection reset by peer", "connection refused", "broken pipe", - "eof", - "timeout", + "unexpected eof", + "read: eof", + "write: eof", + "i/o timeout", + "operation timed out", "temporary failure", "server is overloaded", "too many connections", diff --git a/pkg/consumoor/clickhouse/pool_metrics.go b/pkg/consumoor/clickhouse/pool_metrics.go index 7c7ef4d2a..39f942a44 100644 --- a/pkg/consumoor/clickhouse/pool_metrics.go +++ b/pkg/consumoor/clickhouse/pool_metrics.go @@ -52,6 +52,23 @@ func (w *ChGoWriter) collectPoolMetrics() { } prevCanceledAcquireCount = canceledAcquireCount + + w.collectAdaptiveLimiterMetrics() } } } + +func (w *ChGoWriter) collectAdaptiveLimiterMetrics() { + w.mu.RLock() + defer w.mu.RUnlock() + + for _, tw := range w.tables { + if tw.limiter == nil { + continue + } + + w.metrics.AdaptiveLimiterLimit().WithLabelValues(tw.table).Set(float64(tw.limiter.Limit())) + w.metrics.AdaptiveLimiterInflight().WithLabelValues(tw.table).Set(float64(tw.limiter.Inflight())) + w.metrics.AdaptiveLimiterQueued().WithLabelValues(tw.table).Set(float64(tw.limiter.Queued())) + } +} diff --git a/pkg/consumoor/clickhouse/table_writer.go b/pkg/consumoor/clickhouse/table_writer.go index c9a94c935..efe5c0b70 100644 --- a/pkg/consumoor/clickhouse/table_writer.go +++ b/pkg/consumoor/clickhouse/table_writer.go @@ -4,7 +4,7 @@ import ( "context" "errors" "fmt" - "sync/atomic" + "sync" "time" "github.com/ClickHouse/ch-go" @@ -12,16 +12,9 @@ import ( "github.com/ethpandaops/xatu/pkg/consumoor/telemetry" "github.com/ethpandaops/xatu/pkg/proto/xatu" "github.com/sirupsen/logrus" + "google.golang.org/protobuf/encoding/protojson" ) -// bufferWarningInterval is the minimum time between warning logs per table. -const bufferWarningInterval = time.Minute - -// eventEntry holds a single event for buffering in the table writer. -type eventEntry struct { - event *xatu.DecoratedEvent -} - type chTableWriter struct { log logrus.FieldLogger table string @@ -30,190 +23,30 @@ type chTableWriter struct { config TableConfig metrics *telemetry.Metrics writer *ChGoWriter - buffer chan eventEntry - flushReq chan chan error // coordinator sends a response channel; tableWriter flushes and replies - - organicRetryInitDelay time.Duration - organicRetryMaxDelay time.Duration - drainTimeout time.Duration newBatch func() route.ColumnarBatch - batch route.ColumnarBatch // reused across flushes via Reset() - // lastWarnAt tracks the last time a buffer warning was emitted (Unix nanos). - // Accessed atomically from the Write goroutine for rate limiting. - lastWarnAt atomic.Int64 + // limiter is the per-table adaptive concurrency limiter. + // nil when adaptive limiting is disabled. + limiter *adaptiveConcurrencyLimiter + + // logSampler rate-limits repetitive per-event error logs (e.g. invalid + // events or flatten failures) to avoid flooding when a topic starts + // producing bad data. + logSampler *telemetry.LogSampler + + // Cached per-table strings computed once and reused every flush. + // queryInit ensures thread-safe lazy initialization when maxInFlight > 1. + queryInit sync.Once + queryInitErr error + operationName string + insertQuery string + insertQueryOK bool } -func (tw *chTableWriter) run(done <-chan struct{}) { - ticker := time.NewTicker(tw.config.FlushInterval) - defer ticker.Stop() - - events := make([]eventEntry, 0, tw.config.BatchSize) - flushBlocked := false - retryAttempt := 0 - - for { - bufferCh := tw.buffer - if flushBlocked { - bufferCh = nil - } - - select { - case entry := <-bufferCh: - tw.decrBuffer(1) - - events = append(events, entry) - - if len(events) >= tw.config.BatchSize { - if err := tw.flush(context.Background(), events); err != nil { - var flatErr *flattenError - if errors.As(err, &flatErr) { - events = events[:0] - - continue - } - - if IsPermanentWriteError(err) { - tw.log.WithError(err). - WithField("events", len(events)). - Warn("Dropping permanently invalid batch") - events = events[:0] - flushBlocked = false - retryAttempt = 0 - - continue - } - - // Preserve events for retry on next flush cycle. While - // pending, stop draining tw.buffer so channel backpressure - // remains bounded by BufferSize. - flushBlocked = true - - tw.scheduleOrganicRetry(ticker, retryAttempt) - retryAttempt++ - - continue - } - - events = events[:0] - flushBlocked = false - retryAttempt = 0 - } - - case <-ticker.C: - if len(events) > 0 { - if err := tw.flush(context.Background(), events); err != nil { - var flatErr *flattenError - if errors.As(err, &flatErr) { - events = events[:0] - - continue - } - - if IsPermanentWriteError(err) { - tw.log.WithError(err). - WithField("events", len(events)). - Warn("Dropping permanently invalid batch") - events = events[:0] - flushBlocked = false - - tw.resetRetryState(ticker, &retryAttempt) - - continue - } - - flushBlocked = true - - tw.scheduleOrganicRetry(ticker, retryAttempt) - retryAttempt++ - - continue - } - - events = events[:0] - flushBlocked = false - - tw.resetRetryState(ticker, &retryAttempt) - } - - case errCh := <-tw.flushReq: - if !flushBlocked { - // Drain anything still in the channel into the batch. - drainReq: - for { - select { - case entry := <-tw.buffer: - tw.decrBuffer(1) - - events = append(events, entry) - default: - break drainReq - } - } - } - - if len(events) > 0 { - err := tw.flush(context.Background(), events) - - var flatErr *flattenError - - switch { - case err == nil: - events = events[:0] - flushBlocked = false - - tw.resetRetryState(ticker, &retryAttempt) - case errors.As(err, &flatErr): - events = events[:0] - case IsPermanentWriteError(err): - tw.log.WithError(err). - WithField("events", len(events)). - Warn("Dropping permanently invalid batch") - events = events[:0] - flushBlocked = false - - tw.resetRetryState(ticker, &retryAttempt) - default: - flushBlocked = true - } - // On error: events are PRESERVED for retry on next cycle - errCh <- err - } else { - errCh <- nil - } - - case <-done: - drainLoop: - for { - select { - case entry := <-tw.buffer: - tw.decrBuffer(1) - - events = append(events, entry) - default: - break drainLoop - } - } - - if len(events) > 0 { - drainCtx, drainCancel := context.WithTimeout(context.Background(), tw.drainTimeout) - - if err := tw.flush(drainCtx, events); err != nil { - tw.log.WithError(err).WithField("events", len(events)).Warn("Flush error during shutdown drain") - } - - drainCancel() - } - - return - } - } -} - -func (tw *chTableWriter) flush(ctx context.Context, events []eventEntry) error { +func (tw *chTableWriter) flush(ctx context.Context, events []*xatu.DecoratedEvent) ([]*xatu.DecoratedEvent, error) { if len(events) == 0 { - return nil + return nil, nil } start := time.Now() @@ -223,35 +56,49 @@ func (tw *chTableWriter) flush(ctx context.Context, events []eventEntry) error { Error("No columnar batch factory registered") tw.metrics.WriteErrors().WithLabelValues(tw.table).Add(float64(len(events))) - return &tableWriteError{ + return nil, &tableWriteError{ table: tw.baseTable, cause: &inputPrepError{cause: fmt.Errorf("no columnar batch factory for %s", tw.table)}, } } - if tw.batch == nil { - tw.batch = tw.newBatch() - } else { - tw.batch.Reset() - } - - batch := tw.batch + batch := tw.newBatch() var ( - flattenErrs int - lastErr error + flattenErrs int + lastErr error + invalidEvents []*xatu.DecoratedEvent ) - for _, e := range events { - err := batch.FlattenTo(e.event) + for _, event := range events { + err := batch.FlattenTo(event) if err == nil { continue } if errors.Is(err, route.ErrInvalidEvent) { - tw.log.WithError(err).Warn("Skipping invalid event") tw.metrics.WriteErrors().WithLabelValues(tw.table).Inc() + invalidEvents = append(invalidEvents, event) + + if ok, suppressed := tw.logSampler.Allow("invalid_event"); ok { + entry := tw.log.WithError(err). + WithField("event_name", event.GetEvent().GetName().String()) + if meta := event.GetMeta(); meta != nil && meta.GetClient() != nil { + entry = entry.WithField("client_name", meta.GetClient().GetName()) + } + + if suppressed > 0 { + entry = entry.WithField("suppressed", suppressed) + } + + if jsonBytes, jsonErr := protojson.Marshal(event); jsonErr == nil { + entry = entry.WithField("event_json", string(jsonBytes)) + } + + entry.Warn("Skipping invalid event") + } + continue } @@ -261,11 +108,22 @@ func (tw *chTableWriter) flush(ctx context.Context, events []eventEntry) error { tw.metrics.WriteErrors().WithLabelValues(tw.table).Inc() if !tw.config.SkipFlattenErrors { - tw.log.WithError(err). - WithField("events", len(events)). - Error("Flatten failed (fail-fast)") + if ok, suppressed := tw.logSampler.Allow("flatten_error"); ok { + entry := tw.log.WithError(err). + WithField("events", len(events)). + WithField("event_name", event.GetEvent().GetName().String()) + if suppressed > 0 { + entry = entry.WithField("suppressed", suppressed) + } + + if jsonBytes, jsonErr := protojson.Marshal(event); jsonErr == nil { + entry = entry.WithField("event_json", string(jsonBytes)) + } - return &tableWriteError{ + entry.Error("Flatten failed (fail-fast)") + } + + return invalidEvents, &tableWriteError{ table: tw.baseTable, cause: &flattenError{cause: err}, } @@ -280,7 +138,7 @@ func (tw *chTableWriter) flush(ctx context.Context, events []eventEntry) error { } if flattenErrs == len(events) { - return &tableWriteError{ + return invalidEvents, &tableWriteError{ table: tw.baseTable, cause: &inputPrepError{ cause: fmt.Errorf("all %d events failed FlattenTo for %s", len(events), tw.table), @@ -290,26 +148,41 @@ func (tw *chTableWriter) flush(ctx context.Context, events []eventEntry) error { rows := batch.Rows() if rows == 0 { - return nil + return invalidEvents, nil } input := batch.Input() - insertBody, err := insertQueryWithSettings(input.Into(tw.table), tw.config.InsertSettings) - if err != nil { - tw.log.WithError(err). + // Cache the INSERT query body and operation name on first use. + // Both are invariant between flushes for a given table. + // sync.Once ensures safe concurrent initialization when maxInFlight > 1. + tw.queryInit.Do(func() { + body, qErr := insertQueryWithSettings(input.Into(tw.table), tw.config.InsertSettings) + if qErr != nil { + tw.queryInitErr = qErr + + return + } + + tw.insertQuery = body + tw.operationName = "insert_" + tw.table + tw.insertQueryOK = true + }) + + if !tw.insertQueryOK { + tw.log.WithError(tw.queryInitErr). WithField("rows", rows). Error("Invalid insert settings") tw.metrics.WriteErrors().WithLabelValues(tw.table).Add(float64(rows)) - return &tableWriteError{ + return invalidEvents, &tableWriteError{ table: tw.baseTable, - cause: fmt.Errorf("building insert query for %s: %w", tw.table, err), + cause: fmt.Errorf("building insert query for %s: %w", tw.table, tw.queryInitErr), } } - if err := tw.do(ctx, "insert_"+tw.table, &ch.Query{ - Body: insertBody, + if err := tw.do(ctx, tw.operationName, &ch.Query{ + Body: tw.insertQuery, Input: input, }, nil); err != nil { tw.log.WithError(err). @@ -317,7 +190,7 @@ func (tw *chTableWriter) flush(ctx context.Context, events []eventEntry) error { Error("Failed to send ch-go batch") tw.metrics.WriteErrors().WithLabelValues(tw.table).Add(float64(rows)) - return &tableWriteError{ + return invalidEvents, &tableWriteError{ table: tw.baseTable, cause: fmt.Errorf("sending ch-go batch for %s: %w", tw.table, err), } @@ -334,32 +207,7 @@ func (tw *chTableWriter) flush(ctx context.Context, events []eventEntry) error { WithField("duration", duration). Debug("Flushed ch-go batch") - return nil -} - -// scheduleOrganicRetry resets the ticker interval to an exponential backoff -// delay so the next ticker.C fires after the computed retry delay. -func (tw *chTableWriter) scheduleOrganicRetry(ticker *time.Ticker, attempt int) { - delay := min( - tw.organicRetryInitDelay*time.Duration(1< 0 { - ticker.Reset(tw.config.FlushInterval) - } - - *attempt = 0 + return invalidEvents, nil } func (tw *chTableWriter) do( @@ -368,7 +216,7 @@ func (tw *chTableWriter) do( query *ch.Query, beforeAttempt func(), ) error { - return tw.writer.doWithRetry(ctx, operation, func(attemptCtx context.Context) error { + poolFn := func(attemptCtx context.Context) error { if beforeAttempt != nil { beforeAttempt() } @@ -383,43 +231,18 @@ func (tw *chTableWriter) do( } return pool.Do(attemptCtx, *query) - }) -} - -// checkBufferWarning emits a rate-limited warning when the buffer usage -// exceeds the configured BufferWarningThreshold. Safe to call from any -// goroutine. -func (tw *chTableWriter) checkBufferWarning() { - threshold := tw.writer.config.BufferWarningThreshold - if threshold <= 0 { - return - } - - current := len(tw.buffer) - limit := tw.config.BufferSize - - if float64(current) < threshold*float64(limit) { - return } - now := time.Now().UnixNano() - last := tw.lastWarnAt.Load() - - if now-last < int64(bufferWarningInterval) { - return - } + return tw.writer.doWithRetry(ctx, operation, func(attemptCtx context.Context) error { + if tw.limiter == nil { + return poolFn(attemptCtx) + } - if tw.lastWarnAt.CompareAndSwap(last, now) { - tw.log.WithFields(logrus.Fields{ - "current": current, - "max": limit, - "threshold": threshold, - }).Warn("Buffer usage exceeds warning threshold") - } -} + err := tw.limiter.doWithLimiter(attemptCtx, poolFn) + if IsLimiterRejected(err) { + tw.metrics.AdaptiveLimiterRejections().WithLabelValues(tw.table).Inc() + } -// decrBuffer decrements both the per-table and aggregate buffer gauges. -func (tw *chTableWriter) decrBuffer(n int) { - tw.metrics.BufferUsage().WithLabelValues(tw.table).Sub(float64(n)) - tw.metrics.BufferUsageTotal().Sub(float64(n)) + return err + }) } diff --git a/pkg/consumoor/clickhouse/writer.go b/pkg/consumoor/clickhouse/writer.go index 990df5702..3685f7cba 100644 --- a/pkg/consumoor/clickhouse/writer.go +++ b/pkg/consumoor/clickhouse/writer.go @@ -15,6 +15,32 @@ import ( "github.com/sirupsen/logrus" ) +// FlushResult holds the structured outcome of a FlushTableEvents call. +type FlushResult struct { + // InvalidEvents contains events that failed FlattenTo with + // route.ErrInvalidEvent. These are permanently unflattenable and + // should be sent to the DLQ by the caller. + InvalidEvents []*xatu.DecoratedEvent + + // TableErrors maps base table names to their flush errors. + // Tables that succeeded are absent from the map. + TableErrors map[string]error +} + +// Err returns a joined error of all table failures, or nil if all succeeded. +func (r *FlushResult) Err() error { + if r == nil || len(r.TableErrors) == 0 { + return nil + } + + errs := make([]error, 0, len(r.TableErrors)) + for _, e := range r.TableErrors { + errs = append(errs, e) + } + + return errors.Join(errs...) +} + // ChGoWriter manages batched inserts using the ch-go client. type ChGoWriter struct { log logrus.FieldLogger @@ -36,9 +62,7 @@ type ChGoWriter struct { // registered by route initialization. batchFactories map[string]func() route.ColumnarBatch - done chan struct{} stopOnce sync.Once - wg sync.WaitGroup poolMetricsDone chan struct{} poolMetricsWG sync.WaitGroup @@ -78,7 +102,6 @@ func NewChGoWriter( database: opts.Database, tables: make(map[string]*chTableWriter, 16), batchFactories: make(map[string]func() route.ColumnarBatch, 64), - done: make(chan struct{}), }, nil } @@ -168,14 +191,11 @@ func (w *ChGoWriter) Ping(ctx context.Context) error { return pool.Ping(ctx) } -// Stop drains buffers and closes the connection pool. It is safe to -// call multiple times; only the first call performs cleanup. +// Stop closes the connection pool. It is safe to call multiple times; +// only the first call performs cleanup. func (w *ChGoWriter) Stop(_ context.Context) error { w.stopOnce.Do(func() { - w.log.Info("Stopping ch-go writer, flushing remaining buffers") - - close(w.done) - w.wg.Wait() + w.log.Info("Stopping ch-go writer") if w.poolMetricsDone != nil { close(w.poolMetricsDone) @@ -190,87 +210,88 @@ func (w *ChGoWriter) Stop(_ context.Context) error { return nil } -// Write enqueues an event for table batching. -// Write blocks if the buffer is full, propagating backpressure to the caller. -func (w *ChGoWriter) Write(table string, event *xatu.DecoratedEvent) { - tw := w.getOrCreateTableWriter(table) - - select { - case tw.buffer <- eventEntry{event: event}: - w.metrics.BufferUsage().WithLabelValues(tw.table).Inc() - w.metrics.BufferUsageTotal().Inc() +// FlushTableEvents writes the given events directly to their respective +// ClickHouse tables concurrently. The map keys are base table names +// (without suffix). Returns a FlushResult containing per-table errors +// and any invalid events that should be sent to the DLQ. +func (w *ChGoWriter) FlushTableEvents( + ctx context.Context, + tableEvents map[string][]*xatu.DecoratedEvent, +) *FlushResult { + result := &FlushResult{} - tw.checkBufferWarning() - case <-w.done: - // Shutting down, discard. + if len(tableEvents) == 0 { + return result } -} -// FlushTables forces the specified table writers (by base table name) -// to drain their buffers and write to ClickHouse synchronously. -// Base names are resolved using the configured TableSuffix. -// An empty or nil slice is a no-op that returns nil. -// Returns a joined error containing all table failures so callers can -// identify every failed table in the batch. -func (w *ChGoWriter) FlushTables(ctx context.Context, tables []string) error { - if len(tables) == 0 { - return nil + type tableFlush struct { + tw *chTableWriter + base string + events []*xatu.DecoratedEvent } - w.mu.RLock() - - writers := make([]*chTableWriter, 0, len(tables)) + flushes := make([]tableFlush, 0, len(tableEvents)) - for _, base := range tables { - writeTable := base + w.config.TableSuffix - if tw, ok := w.tables[writeTable]; ok { - writers = append(writers, tw) + for base, events := range tableEvents { + if len(events) == 0 { + continue } + + tw := w.getOrCreateTableWriter(base) + flushes = append(flushes, tableFlush{tw: tw, base: base, events: events}) } - w.mu.RUnlock() + if len(flushes) == 0 { + return result + } - if len(writers) == 0 { - return nil + type flushOutcome struct { + base string + invalidEvents []*xatu.DecoratedEvent + err error } - // Send flush requests to matched table writers in parallel. - errChs := make([]chan error, len(writers)) + outcomes := make([]flushOutcome, len(flushes)) - for i, tw := range writers { - errCh := make(chan error, 1) - errChs[i] = errCh + var wg sync.WaitGroup - select { - case tw.flushReq <- errCh: - case <-w.done: - return nil - case <-ctx.Done(): - return ctx.Err() - } + wg.Add(len(flushes)) + + for i, f := range flushes { + go func(idx int, f tableFlush) { + defer wg.Done() + + invalid, err := f.tw.flush(ctx, f.events) + outcomes[idx] = flushOutcome{base: f.base, invalidEvents: invalid, err: err} + }(i, f) } - // Collect results — return all errors joined. - errs := make([]error, 0, len(errChs)) + wg.Wait() + + for _, o := range outcomes { + if len(o.invalidEvents) > 0 { + result.InvalidEvents = append(result.InvalidEvents, o.invalidEvents...) + } - for _, errCh := range errChs { - select { - case err := <-errCh: - if err != nil { - errs = append(errs, err) + if o.err != nil { + if result.TableErrors == nil { + result.TableErrors = make(map[string]error, len(flushes)) } - case <-w.done: - return errors.Join(errs...) - case <-ctx.Done(): - errs = append(errs, ctx.Err()) + + result.TableErrors[o.base] = o.err } } - return errors.Join(errs...) + return result } func (w *ChGoWriter) getOrCreateTableWriter(table string) *chTableWriter { - writeTable := table + w.config.TableSuffix + var writeTable string + if w.config.TableSuffix == "" { + writeTable = table + } else { + writeTable = table + w.config.TableSuffix + } w.mu.RLock() tw, ok := w.tables[writeTable] @@ -291,30 +312,21 @@ func (w *ChGoWriter) getOrCreateTableWriter(table string) *chTableWriter { // don't need to include the suffix. cfg := w.config.TableConfigFor(table) tw = &chTableWriter{ - log: w.log.WithField("table", writeTable), - table: writeTable, - baseTable: table, - database: w.database, - config: cfg, - metrics: w.metrics, - writer: w, - buffer: make(chan eventEntry, cfg.BufferSize), - flushReq: make(chan chan error, 1), - organicRetryInitDelay: w.config.OrganicRetryInitDelay, - organicRetryMaxDelay: w.config.OrganicRetryMaxDelay, - drainTimeout: w.config.DrainTimeout, - newBatch: w.batchFactories[table], + log: w.log.WithField("table", writeTable), + table: writeTable, + baseTable: table, + database: w.database, + config: cfg, + metrics: w.metrics, + writer: w, + newBatch: w.batchFactories[table], + limiter: newAdaptiveConcurrencyLimiter(w.chgoCfg.AdaptiveLimiter), + logSampler: telemetry.NewLogSampler(30 * time.Second), } w.tables[writeTable] = tw - w.wg.Go(func() { - tw.run(w.done) - }) - w.log.WithField("table", writeTable). - WithField("batch_size", cfg.BatchSize). - WithField("flush_interval", cfg.FlushInterval). WithField("has_batch_factory", tw.newBatch != nil). Info("Created ch-go table writer") @@ -356,6 +368,8 @@ func (w *ChGoWriter) doWithRetry( for attempt := 0; attempt <= w.chgoCfg.MaxRetries; attempt++ { if attempt > 0 { + w.metrics.WriteRetries().WithLabelValues(operation).Inc() + delay := min( w.chgoCfg.RetryBaseDelay*time.Duration(1<<(attempt-1)), w.chgoCfg.RetryMaxDelay, @@ -387,6 +401,10 @@ func (w *ChGoWriter) doWithRetry( lastErr = err + if IsLimiterRejected(err) { + return err + } + if !isRetryableError(err) { return err } diff --git a/pkg/consumoor/clickhouse/writer_benchmark_test.go b/pkg/consumoor/clickhouse/writer_benchmark_test.go index b186d12cf..32b093e76 100644 --- a/pkg/consumoor/clickhouse/writer_benchmark_test.go +++ b/pkg/consumoor/clickhouse/writer_benchmark_test.go @@ -3,7 +3,6 @@ package clickhouse import ( "context" "fmt" - "sync" "sync/atomic" "testing" "time" @@ -78,8 +77,7 @@ func benchHeadEvent() *xatu.DecoratedEvent { } // benchWriter creates a ChGoWriter with a noop pool.Do for benchmarking. -// The returned cancel function must be called to stop background goroutines. -func benchWriter(tb testing.TB, batchSize, bufferSize int) (*ChGoWriter, context.CancelFunc) { +func benchWriter(tb testing.TB) *ChGoWriter { tb.Helper() ns := fmt.Sprintf("xatu_bench_%d", time.Now().UnixNano()) @@ -91,14 +89,7 @@ func benchWriter(tb testing.TB, batchSize, bufferSize int) (*ChGoWriter, context w := &ChGoWriter{ log: log.WithField("component", "bench"), metrics: metrics, - config: &Config{ - DrainTimeout: 30 * time.Second, - Defaults: TableConfig{ - BatchSize: batchSize, - FlushInterval: 10 * time.Second, - BufferSize: bufferSize, - }, - }, + config: &Config{}, chgoCfg: ChGoConfig{ MaxRetries: 0, RetryBaseDelay: 100 * time.Millisecond, @@ -106,7 +97,6 @@ func benchWriter(tb testing.TB, batchSize, bufferSize int) (*ChGoWriter, context }, tables: make(map[string]*chTableWriter, 4), batchFactories: make(map[string]func() route.ColumnarBatch, 4), - done: make(chan struct{}), poolDoFn: func(_ context.Context, _ ch.Query) error { return nil }, @@ -117,130 +107,97 @@ func benchWriter(tb testing.TB, batchSize, bufferSize int) (*ChGoWriter, context w.RegisterBatchFactories(routes) - cancel := func() { - w.stopOnce.Do(func() { - close(w.done) - w.wg.Wait() - }) - } - - return w, cancel + return w } -// BenchmarkWriteThroughput measures events/sec through the full -// Write() -> accumulator -> worker -> noop-flush path. -func BenchmarkWriteThroughput(b *testing.B) { - const ( - batchSize = 10_000 - bufferSize = 50_000 - ) - - w, cancel := benchWriter(b, batchSize, bufferSize) - defer cancel() - +// BenchmarkFlushTableEvents measures throughput of the FlushTableEvents path +// (FlattenTo + columnar batch build + noop INSERT). +func BenchmarkFlushTableEvents(b *testing.B) { + w := benchWriter(b) event := benchHeadEvent() b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - w.Write(benchTable, event) - } - - b.StopTimer() - - ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Second) - defer ctxCancel() + tableEvents := map[string][]*xatu.DecoratedEvent{ + benchTable: {event}, + } - if err := w.FlushTables(ctx, []string{benchTable}); err != nil { - b.Logf("FlushTables: %v", err) + if err := w.FlushTableEvents(context.Background(), tableEvents).Err(); err != nil { + b.Fatalf("FlushTableEvents: %v", err) + } } + b.StopTimer() b.ReportMetric(float64(b.N)/b.Elapsed().Seconds(), "events/sec") } -// BenchmarkWriteConcurrent measures channel contention when multiple -// goroutines write to the same ChGoWriter concurrently. -func BenchmarkWriteConcurrent(b *testing.B) { - const ( - batchSize = 10_000 - bufferSize = 100_000 - ) - - w, cancel := benchWriter(b, batchSize, bufferSize) - defer cancel() +// BenchmarkFlushTableEventsBatch measures throughput with larger batches. +func BenchmarkFlushTableEventsBatch(b *testing.B) { + const batchSize = 500 + w := benchWriter(b) event := benchHeadEvent() + // Pre-build the batch of events. + events := make([]*xatu.DecoratedEvent, batchSize) + for i := range events { + events[i] = event + } + b.ReportAllocs() b.ResetTimer() - b.RunParallel(func(pb *testing.PB) { - for pb.Next() { - w.Write(benchTable, event) + for i := 0; i < b.N; i++ { + tableEvents := map[string][]*xatu.DecoratedEvent{ + benchTable: events, } - }) - - b.StopTimer() - - ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Second) - defer ctxCancel() - if err := w.FlushTables(ctx, []string{benchTable}); err != nil { - b.Logf("FlushTables: %v", err) + if err := w.FlushTableEvents(context.Background(), tableEvents).Err(); err != nil { + b.Fatalf("FlushTableEvents: %v", err) + } } - b.ReportMetric(float64(b.N)/b.Elapsed().Seconds(), "events/sec") + b.StopTimer() + b.ReportMetric(float64(b.N*batchSize)/b.Elapsed().Seconds(), "events/sec") } -// BenchmarkAccumulatorBatching measures how fast the table writer's -// run loop drains the buffer channel and builds batches via flush. -func BenchmarkAccumulatorBatching(b *testing.B) { - const ( - batchSize = 10_000 - bufferSize = 50_000 - ) - - w, cancel := benchWriter(b, batchSize, bufferSize) - defer cancel() +// BenchmarkFlushConcurrent measures throughput when multiple goroutines +// flush concurrently, exercising the concurrent INSERT path. +func BenchmarkFlushConcurrent(b *testing.B) { + const batchSize = 500 + w := benchWriter(b) event := benchHeadEvent() - // Pre-populate the buffer to measure drain/flush speed. - // First trigger table writer creation by writing one event. - w.Write(benchTable, event) - - // Wait briefly for the table writer goroutine to start. - time.Sleep(10 * time.Millisecond) + events := make([]*xatu.DecoratedEvent, batchSize) + for i := range events { + events[i] = event + } b.ReportAllocs() b.ResetTimer() - for i := 0; i < b.N; i++ { - w.Write(benchTable, event) - } - - b.StopTimer() - - ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Second) - defer ctxCancel() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + tableEvents := map[string][]*xatu.DecoratedEvent{ + benchTable: events, + } - if err := w.FlushTables(ctx, []string{benchTable}); err != nil { - b.Logf("FlushTables: %v", err) - } + if err := w.FlushTableEvents(context.Background(), tableEvents).Err(); err != nil { + b.Logf("FlushTableEvents: %v", err) + } + } + }) - // Count total flushes by reading the metrics. - b.ReportMetric(float64(b.N)/b.Elapsed().Seconds(), "events/sec") + b.StopTimer() + b.ReportMetric(float64(b.N*batchSize)/b.Elapsed().Seconds(), "events/sec") } // BenchmarkEndToEndWithFlatten measures the full cost of processing one -// event from proto through FlattenTo and the Write path to batch-ready. +// event from proto through FlattenTo to batch-ready INSERT. func BenchmarkEndToEndWithFlatten(b *testing.B) { - const ( - batchSize = 10_000 - bufferSize = 50_000 - ) - var flushCount atomic.Int64 ns := fmt.Sprintf("xatu_bench_e2e_%d", time.Now().UnixNano()) @@ -252,14 +209,7 @@ func BenchmarkEndToEndWithFlatten(b *testing.B) { w := &ChGoWriter{ log: log.WithField("component", "bench_e2e"), metrics: metrics, - config: &Config{ - DrainTimeout: 30 * time.Second, - Defaults: TableConfig{ - BatchSize: batchSize, - FlushInterval: 10 * time.Second, - BufferSize: bufferSize, - }, - }, + config: &Config{}, chgoCfg: ChGoConfig{ MaxRetries: 0, RetryBaseDelay: 100 * time.Millisecond, @@ -267,7 +217,6 @@ func BenchmarkEndToEndWithFlatten(b *testing.B) { }, tables: make(map[string]*chTableWriter, 4), batchFactories: make(map[string]func() route.ColumnarBatch, 4), - done: make(chan struct{}), poolDoFn: func(_ context.Context, _ ch.Query) error { flushCount.Add(1) @@ -280,39 +229,22 @@ func BenchmarkEndToEndWithFlatten(b *testing.B) { w.RegisterBatchFactories(routes) - var wg sync.WaitGroup - event := benchHeadEvent() b.ReportAllocs() b.ResetTimer() - wg.Add(1) - - go func() { - defer wg.Done() - - for i := 0; i < b.N; i++ { - w.Write(benchTable, event) + for i := 0; i < b.N; i++ { + tableEvents := map[string][]*xatu.DecoratedEvent{ + benchTable: {event}, } - }() - - wg.Wait() - b.StopTimer() - - ctx, ctxCancel := context.WithTimeout(context.Background(), 10*time.Second) - defer ctxCancel() - - if err := w.FlushTables(ctx, []string{benchTable}); err != nil { - b.Logf("FlushTables: %v", err) + if err := w.FlushTableEvents(context.Background(), tableEvents).Err(); err != nil { + b.Fatalf("FlushTableEvents: %v", err) + } } - // Shut down the table writer goroutines. - w.stopOnce.Do(func() { - close(w.done) - w.wg.Wait() - }) + b.StopTimer() elapsed := b.Elapsed().Seconds() b.ReportMetric(float64(b.N)/elapsed, "events/sec") diff --git a/pkg/consumoor/clickhouse/writer_test.go b/pkg/consumoor/clickhouse/writer_test.go index 34c3410cc..eb9cd946a 100644 --- a/pkg/consumoor/clickhouse/writer_test.go +++ b/pkg/consumoor/clickhouse/writer_test.go @@ -14,6 +14,7 @@ import ( "github.com/ClickHouse/ch-go/proto" "github.com/ethpandaops/xatu/pkg/consumoor/route" "github.com/ethpandaops/xatu/pkg/consumoor/telemetry" + "github.com/ethpandaops/xatu/pkg/proto/xatu" "github.com/sirupsen/logrus" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -41,16 +42,8 @@ func newTestWriter(maxRetries int, baseDelay, maxDelay time.Duration) *ChGoWrite log.SetLevel(logrus.DebugLevel) return &ChGoWriter{ - log: log.WithField("component", "test"), - config: &Config{ - DSN: "clickhouse://localhost:9000/default", - DrainTimeout: 30 * time.Second, - Defaults: TableConfig{ - BatchSize: 100, - FlushInterval: time.Second, - BufferSize: 100, - }, - }, + log: log.WithField("component", "test"), + config: &Config{}, metrics: sharedTestMetrics(), chgoCfg: ChGoConfig{ MaxRetries: maxRetries, @@ -60,7 +53,6 @@ func newTestWriter(maxRetries int, baseDelay, maxDelay time.Duration) *ChGoWrite }, tables: make(map[string]*chTableWriter, 16), batchFactories: make(map[string]func() route.ColumnarBatch, 8), - done: make(chan struct{}), } } @@ -85,7 +77,7 @@ func TestChGoConfigValidateAcceptsValidConfig(t *testing.T) { ReadTimeout: 30 * time.Second, RetryBaseDelay: 100 * time.Millisecond, RetryMaxDelay: 2 * time.Second, - MaxConns: 8, + MaxConns: 32, MinConns: 0, ConnMaxLifetime: time.Hour, ConnMaxIdleTime: 10 * time.Minute, @@ -145,26 +137,46 @@ func TestIsPermanentWriteError(t *testing.T) { cause: &inputPrepError{cause: errors.New("no batch factory")}, })) + // Data-quality errors are permanent. assert.True(t, IsPermanentWriteError(&tableWriteError{ + table: "beacon_head", + cause: &ch.Exception{ + Code: proto.ErrCannotParseNumber, + Name: "CANNOT_PARSE_NUMBER", + Message: "bad number", + }, + })) + + // Schema mismatches are NOT permanent — they can resolve after migration. + assert.False(t, IsPermanentWriteError(&tableWriteError{ table: "beacon_head", cause: &ch.Exception{ Code: proto.ErrUnknownIdentifier, Name: "UNKNOWN_IDENTIFIER", Message: "unknown column", }, - })) + }), "schema errors should not be permanent (transient during deploys)") + + assert.False(t, IsPermanentWriteError(&tableWriteError{ + table: "beacon_head", + cause: &ch.Exception{ + Code: proto.ErrUnknownTable, + Name: "UNKNOWN_TABLE", + Message: "table not found", + }, + }), "unknown table should not be permanent (transient during deploys)") assert.False(t, IsPermanentWriteError(errors.New("dial tcp timeout"))) } -func TestFlattenErrorIsNotPermanent(t *testing.T) { +func TestFlattenErrorIsPermanent(t *testing.T) { err := &tableWriteError{ table: "beacon_head", cause: &flattenError{cause: errors.New("bad proto field")}, } - assert.False(t, IsPermanentWriteError(err), - "flattenError must NOT be classified as permanent") + assert.True(t, IsPermanentWriteError(err), + "flattenError must be classified as permanent") var flatErr *flattenError assert.True(t, errors.As(err, &flatErr), @@ -187,10 +199,20 @@ func TestIsPermanentWriteErrorJoined(t *testing.T) { cause: errors.New("connection reset"), } - t.Run("joined with permanent sub-error", func(t *testing.T) { + t.Run("mixed permanent and transient is NOT permanent", func(t *testing.T) { joined := errors.Join(permanent, transient) + assert.False(t, IsPermanentWriteError(joined), + "joined error with any transient sub-error should NOT be permanent (NAK for retry)") + }) + + t.Run("all permanent sub-errors is permanent", func(t *testing.T) { + permanent2 := &tableWriteError{ + table: "table_c", + cause: &inputPrepError{cause: errors.New("another schema issue")}, + } + joined := errors.Join(permanent, permanent2) assert.True(t, IsPermanentWriteError(joined), - "joined error containing a permanent sub-error should be permanent") + "joined error with only permanent sub-errors should be permanent") }) t.Run("joined with only transient sub-errors", func(t *testing.T) { @@ -202,6 +224,12 @@ func TestIsPermanentWriteErrorJoined(t *testing.T) { assert.False(t, IsPermanentWriteError(joined), "joined error with only transient sub-errors should not be permanent") }) + + t.Run("joined with nil sub-errors", func(t *testing.T) { + joined := errors.Join(nil, permanent, nil) + assert.True(t, IsPermanentWriteError(joined), + "nil sub-errors should be ignored; remaining permanent error makes it permanent") + }) } // --------------------------------------------------------------------------- @@ -301,6 +329,22 @@ func TestDoWithRetry_NonRetryableExitsImmediately(t *testing.T) { assert.Equal(t, int32(1), calls.Load()) } +func TestDoWithRetry_LimiterRejectionExitsImmediately(t *testing.T) { + w := newTestWriter(5, time.Millisecond, 10*time.Millisecond) + + var calls atomic.Int32 + + err := w.doWithRetry(context.Background(), "test_op", func(_ context.Context) error { + calls.Add(1) + + return &limiterRejectedError{cause: errors.New("limit exceeded")} + }) + + require.Error(t, err) + assert.True(t, IsLimiterRejected(err), "error should be classified as limiter rejected") + assert.Equal(t, int32(1), calls.Load(), "should not retry on limiter rejection") +} + func TestDoWithRetry_BackoffTiming(t *testing.T) { baseDelay := 20 * time.Millisecond maxDelay := 100 * time.Millisecond @@ -415,208 +459,75 @@ func TestGetOrCreateTableWriter_DifferentTablesGetDifferentWriters(t *testing.T) assert.Len(t, w.tables, 2) } -func TestBufferWarningThresholdValidation(t *testing.T) { - validChGo := ChGoConfig{ - DialTimeout: 5 * time.Second, - ReadTimeout: 30 * time.Second, - RetryBaseDelay: 100 * time.Millisecond, - RetryMaxDelay: 2 * time.Second, - MaxConns: 8, - MinConns: 1, - ConnMaxLifetime: time.Hour, - ConnMaxIdleTime: 10 * time.Minute, - HealthCheckPeriod: 30 * time.Second, - } +func TestFlushTableEvents_ConcurrentFlush(t *testing.T) { + w := newTestWriter(0, time.Millisecond, time.Millisecond) - t.Run("accepts 0", func(t *testing.T) { - cfg := &Config{ - DSN: "clickhouse://localhost:9000/default", - Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, - }, - OrganicRetryInitDelay: time.Second, - OrganicRetryMaxDelay: 30 * time.Second, - DrainTimeout: 30 * time.Second, - BufferWarningThreshold: 0, - ChGo: validChGo, - } - require.NoError(t, cfg.Validate()) - }) + var flushCount atomic.Int32 - t.Run("accepts 0.8", func(t *testing.T) { - cfg := &Config{ - DSN: "clickhouse://localhost:9000/default", - Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, - }, - OrganicRetryInitDelay: time.Second, - OrganicRetryMaxDelay: 30 * time.Second, - DrainTimeout: 30 * time.Second, - BufferWarningThreshold: 0.8, - ChGo: validChGo, - } - require.NoError(t, cfg.Validate()) - }) + w.poolDoFn = func(_ context.Context, _ ch.Query) error { + flushCount.Add(1) - t.Run("accepts 1", func(t *testing.T) { - cfg := &Config{ - DSN: "clickhouse://localhost:9000/default", - Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, - }, - OrganicRetryInitDelay: time.Second, - OrganicRetryMaxDelay: 30 * time.Second, - DrainTimeout: 30 * time.Second, - BufferWarningThreshold: 1.0, - ChGo: validChGo, - } - require.NoError(t, cfg.Validate()) - }) + return nil + } - t.Run("rejects negative", func(t *testing.T) { - cfg := &Config{ - DSN: "clickhouse://localhost:9000/default", - Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, - }, - OrganicRetryInitDelay: time.Second, - OrganicRetryMaxDelay: 30 * time.Second, - DrainTimeout: 30 * time.Second, - BufferWarningThreshold: -0.1, - ChGo: validChGo, - } - err := cfg.Validate() - require.Error(t, err) - assert.Contains(t, err.Error(), "bufferWarningThreshold") - }) + const table = "beacon_block" - t.Run("rejects greater than 1", func(t *testing.T) { - cfg := &Config{ - DSN: "clickhouse://localhost:9000/default", - Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, - }, - OrganicRetryInitDelay: time.Second, - OrganicRetryMaxDelay: 30 * time.Second, - DrainTimeout: 30 * time.Second, - BufferWarningThreshold: 1.5, - ChGo: validChGo, - } - err := cfg.Validate() - require.Error(t, err) - assert.Contains(t, err.Error(), "bufferWarningThreshold") - }) -} + w.batchFactories[table] = func() route.ColumnarBatch { + return &stubBatch{} + } -func TestCheckBufferWarning(t *testing.T) { - t.Run("no warning below threshold", func(t *testing.T) { - tw := &chTableWriter{ - log: logrus.New().WithField("test", true), - table: "test_table", - config: TableConfig{BufferSize: 100}, - writer: &ChGoWriter{ - config: &Config{BufferWarningThreshold: 0.8}, - }, - buffer: make(chan eventEntry, 100), - } + event := &xatu.DecoratedEvent{} - // Fill to 50% -- below 80% threshold - for i := 0; i < 50; i++ { - tw.buffer <- eventEntry{} - } + // Launch multiple concurrent FlushTableEvents calls. + const flushers = 10 - tw.checkBufferWarning() - assert.Equal(t, int64(0), tw.lastWarnAt.Load(), - "should not warn when below threshold") - }) + results := make([]*FlushResult, flushers) - t.Run("warns above threshold", func(t *testing.T) { - tw := &chTableWriter{ - log: logrus.New().WithField("test", true), - table: "test_table", - config: TableConfig{BufferSize: 100}, - writer: &ChGoWriter{ - config: &Config{BufferWarningThreshold: 0.8}, - }, - buffer: make(chan eventEntry, 100), - } + var wg sync.WaitGroup - // Fill to 85% -- above 80% threshold - for i := 0; i < 85; i++ { - tw.buffer <- eventEntry{} - } + wg.Add(flushers) - tw.checkBufferWarning() - assert.NotEqual(t, int64(0), tw.lastWarnAt.Load(), - "should warn when above threshold") - }) + for i := 0; i < flushers; i++ { + go func(idx int) { + defer wg.Done() - t.Run("rate limits warnings", func(t *testing.T) { - tw := &chTableWriter{ - log: logrus.New().WithField("test", true), - table: "test_table", - config: TableConfig{BufferSize: 100}, - writer: &ChGoWriter{ - config: &Config{BufferWarningThreshold: 0.8}, - }, - buffer: make(chan eventEntry, 100), - } + results[idx] = w.FlushTableEvents(context.Background(), map[string][]*xatu.DecoratedEvent{ + table: {event}, + }) + }(i) + } - // Fill above threshold - for i := 0; i < 85; i++ { - tw.buffer <- eventEntry{} - } + wg.Wait() - tw.checkBufferWarning() - firstWarn := tw.lastWarnAt.Load() - require.NotEqual(t, int64(0), firstWarn) + for i, result := range results { + assert.NoError(t, result.Err(), "flusher %d returned error", i) + } - // Second call should not update the timestamp (rate limited) - tw.checkBufferWarning() - assert.Equal(t, firstWarn, tw.lastWarnAt.Load(), - "should rate-limit warnings within the interval") - }) + assert.Equal(t, int32(flushers), flushCount.Load(), "each flush should have triggered a pool.Do call") +} - t.Run("disabled when threshold is 0", func(t *testing.T) { - tw := &chTableWriter{ - log: logrus.New().WithField("test", true), - table: "test_table", - config: TableConfig{BufferSize: 100}, - writer: &ChGoWriter{ - config: &Config{BufferWarningThreshold: 0}, - }, - buffer: make(chan eventEntry, 100), - } +// stubBatch is a minimal ColumnarBatch implementation for unit tests. +type stubBatch struct { + rows int +} - // Fill to 100% - for i := 0; i < 100; i++ { - tw.buffer <- eventEntry{} - } +func (s *stubBatch) FlattenTo(_ *xatu.DecoratedEvent) error { + s.rows++ - tw.checkBufferWarning() - assert.Equal(t, int64(0), tw.lastWarnAt.Load(), - "should not warn when threshold is disabled (0)") - }) + return nil } +func (s *stubBatch) Rows() int { return s.rows } + +func (s *stubBatch) Input() proto.Input { return proto.Input{} } + +func (s *stubBatch) Reset() { s.rows = 0 } + func TestTableConfigMergeSkipFlattenErrors(t *testing.T) { t.Run("default inherits from defaults", func(t *testing.T) { cfg := &Config{ DSN: "clickhouse://localhost", Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, SkipFlattenErrors: true, }, } @@ -627,11 +538,6 @@ func TestTableConfigMergeSkipFlattenErrors(t *testing.T) { t.Run("override enables skip", func(t *testing.T) { cfg := &Config{ DSN: "clickhouse://localhost", - Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, - }, Tables: map[string]TableConfig{ "some_table": {SkipFlattenErrors: true}, }, @@ -644,9 +550,6 @@ func TestTableConfigMergeSkipFlattenErrors(t *testing.T) { cfg := &Config{ DSN: "clickhouse://localhost", Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, SkipFlattenErrors: true, }, Tables: map[string]TableConfig{ @@ -660,11 +563,6 @@ func TestTableConfigMergeSkipFlattenErrors(t *testing.T) { t.Run("both false stays false", func(t *testing.T) { cfg := &Config{ DSN: "clickhouse://localhost", - Defaults: TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, - }, Tables: map[string]TableConfig{ "some_table": {}, }, diff --git a/pkg/consumoor/config.go b/pkg/consumoor/config.go index 3f9b0b912..fa45341ef 100644 --- a/pkg/consumoor/config.go +++ b/pkg/consumoor/config.go @@ -1,6 +1,7 @@ package consumoor import ( + "errors" "fmt" "sort" "strings" @@ -30,6 +31,10 @@ type Config struct { // Validate checks the configuration for errors. func (c *Config) Validate() error { + if c.MetricsAddr == "" { + return errors.New("metricsAddr is required") + } + if err := c.Kafka.Validate(); err != nil { return err } diff --git a/pkg/consumoor/config_test.go b/pkg/consumoor/config_test.go index f2d9ebf23..342c9535e 100644 --- a/pkg/consumoor/config_test.go +++ b/pkg/consumoor/config_test.go @@ -20,7 +20,7 @@ func validChGoConfig() clickhouse.ChGoConfig { MaxRetries: 3, RetryBaseDelay: 100 * time.Millisecond, RetryMaxDelay: 2 * time.Second, - MaxConns: 8, + MaxConns: 32, MinConns: 1, ConnMaxLifetime: time.Hour, ConnMaxIdleTime: 10 * time.Minute, @@ -32,30 +32,28 @@ func validChGoConfig() clickhouse.ChGoConfig { // validClickHouseConfig returns a clickhouse.Config that passes validation. func validClickHouseConfig() *clickhouse.Config { return &clickhouse.Config{ - DSN: "clickhouse://localhost:9000/default", - Defaults: clickhouse.TableConfig{ - BatchSize: 1000, - FlushInterval: time.Second, - BufferSize: 1000, - }, - OrganicRetryInitDelay: time.Second, - OrganicRetryMaxDelay: 30 * time.Second, - DrainTimeout: 30 * time.Second, - ChGo: validChGoConfig(), + DSN: "clickhouse://localhost:9000/default", + ChGo: validChGoConfig(), } } // validKafkaConfig returns a KafkaConfig that passes validation. func validKafkaConfig() *source.KafkaConfig { return &source.KafkaConfig{ - Brokers: []string{"localhost:9092"}, - Topics: []string{"^test-.+"}, - ConsumerGroup: "test-group", - Encoding: "json", - OffsetDefault: "earliest", - SessionTimeoutMs: 30000, - CommitInterval: 5 * time.Second, - ShutdownTimeout: 30 * time.Second, + Brokers: []string{"localhost:9092"}, + Topics: []string{"^test-.+"}, + ConsumerGroup: "test-group", + Encoding: "json", + OffsetDefault: "earliest", + SessionTimeoutMs: 30000, + RebalanceTimeout: 15 * time.Second, + CommitInterval: 5 * time.Second, + ShutdownTimeout: 30 * time.Second, + MaxInFlight: 64, + FetchMinBytes: 1, + FetchWaitMaxMs: 250, + MaxPartitionFetchBytes: 3145728, + FetchMaxBytes: 10485760, } } @@ -134,9 +132,6 @@ func TestClickHouseConfigValidateChGo(t *testing.T) { func TestTableConfigForMergesInsertSettings(t *testing.T) { cfg := &clickhouse.Config{ Defaults: clickhouse.TableConfig{ - BatchSize: 100, - FlushInterval: time.Second, - BufferSize: 300, InsertSettings: map[string]any{ "insert_quorum": 2, "insert_quorum_timeout": 30000, @@ -144,7 +139,6 @@ func TestTableConfigForMergesInsertSettings(t *testing.T) { }, Tables: map[string]clickhouse.TableConfig{ "canonical_beacon_block": { - BatchSize: 500, InsertSettings: map[string]any{ "insert_quorum": 3, }, @@ -154,8 +148,6 @@ func TestTableConfigForMergesInsertSettings(t *testing.T) { got := cfg.TableConfigFor("canonical_beacon_block") - assert.Equal(t, 500, got.BatchSize) - assert.Equal(t, 300, got.BufferSize) assert.Equal( t, map[string]any{ @@ -247,47 +239,16 @@ func TestKafkaConfigValidateSessionTimeout(t *testing.T) { }) } -func TestClickHouseConfigValidateBufferSize(t *testing.T) { - t.Run("rejects bufferSize less than batchSize", func(t *testing.T) { - cfg := validClickHouseConfig() - cfg.Defaults.BatchSize = 1000 - cfg.Defaults.BufferSize = 500 - - err := cfg.Validate() - require.Error(t, err) - assert.Contains(t, err.Error(), "bufferSize must be >= batchSize") - }) - - t.Run("accepts bufferSize equal to batchSize", func(t *testing.T) { - cfg := validClickHouseConfig() - cfg.Defaults.BatchSize = 1000 - cfg.Defaults.BufferSize = 1000 - require.NoError(t, cfg.Validate()) - }) -} - func TestTableConfigForAppliesCanonicalDefaults(t *testing.T) { t.Run("adds auto quorum for canonical tables when unset", func(t *testing.T) { - cfg := &clickhouse.Config{ - Defaults: clickhouse.TableConfig{ - BatchSize: 100, - FlushInterval: time.Second, - BufferSize: 300, - }, - } + cfg := &clickhouse.Config{} got := cfg.TableConfigFor("canonical_beacon_block") assert.Equal(t, map[string]any{"insert_quorum": "auto"}, got.InsertSettings) }) t.Run("does not add quorum for non-canonical tables", func(t *testing.T) { - cfg := &clickhouse.Config{ - Defaults: clickhouse.TableConfig{ - BatchSize: 100, - FlushInterval: time.Second, - BufferSize: 300, - }, - } + cfg := &clickhouse.Config{} got := cfg.TableConfigFor("beacon_api_eth_v1_events_head") assert.Nil(t, got.InsertSettings) @@ -295,11 +256,6 @@ func TestTableConfigForAppliesCanonicalDefaults(t *testing.T) { t.Run("preserves explicit per-table quorum", func(t *testing.T) { cfg := &clickhouse.Config{ - Defaults: clickhouse.TableConfig{ - BatchSize: 100, - FlushInterval: time.Second, - BufferSize: 300, - }, Tables: map[string]clickhouse.TableConfig{ "canonical_beacon_block": { InsertSettings: map[string]any{ @@ -316,9 +272,6 @@ func TestTableConfigForAppliesCanonicalDefaults(t *testing.T) { t.Run("preserves explicit default quorum", func(t *testing.T) { cfg := &clickhouse.Config{ Defaults: clickhouse.TableConfig{ - BatchSize: 100, - FlushInterval: time.Second, - BufferSize: 300, InsertSettings: map[string]any{ "insert_quorum": 2, }, diff --git a/pkg/consumoor/consumoor.go b/pkg/consumoor/consumoor.go index 472e04155..4eb2a1fda 100644 --- a/pkg/consumoor/consumoor.go +++ b/pkg/consumoor/consumoor.go @@ -9,6 +9,7 @@ import ( "net/http" "os/signal" "regexp" + "strings" "sync" "syscall" "time" @@ -38,8 +39,9 @@ type topicStream struct { // Benthos stream and consumer group while sharing a single ClickHouse // writer for efficient connection reuse. type Consumoor struct { - log logrus.FieldLogger - config *Config + log logrus.FieldLogger + parentLog logrus.FieldLogger + config *Config metrics *telemetry.Metrics router *router.Engine @@ -47,6 +49,10 @@ type Consumoor struct { streams []topicStream lagMonitor *source.LagMonitor + // activeTopics tracks topics that have a running stream to avoid + // creating duplicate streams when watchTopics re-discovers them. + activeTopics map[string]struct{} + mu sync.Mutex metricsServer *http.Server pprofServer *http.Server @@ -113,12 +119,23 @@ func New( Info("Discovered Kafka topics for per-topic streams") streams := make([]topicStream, 0, len(topics)) + consumerGroups := make([]string, 0, len(topics)) for _, topic := range topics { - topicKafkaCfg := config.Kafka + topicKafkaCfg := config.Kafka.ApplyTopicOverride(topic) topicKafkaCfg.Topics = []string{"^" + regexp.QuoteMeta(topic) + "$"} topicKafkaCfg.ConsumerGroup = config.Kafka.ConsumerGroup + "-" + topic + consumerGroups = append(consumerGroups, topicKafkaCfg.ConsumerGroup) + + if _, hasOverride := config.Kafka.TopicOverrides[topic]; hasOverride { + cLog.WithField("topic", topic). + WithField("outputBatchCount", topicKafkaCfg.OutputBatchCount). + WithField("outputBatchPeriod", topicKafkaCfg.OutputBatchPeriod). + WithField("maxInFlight", topicKafkaCfg.MaxInFlight). + Info("Applied per-topic batch overrides") + } + stream, sErr := source.NewBenthosStream( log.WithField("topic", topic), config.LoggingLevel, @@ -127,6 +144,11 @@ func New( rtr, writer, false, // writer lifecycle owned by Consumoor, not the output plugin + source.GroupRetryConfig{ + MaxAttempts: config.ClickHouse.ChGo.GroupRetryMaxAttempts, + BaseDelay: config.ClickHouse.ChGo.GroupRetryBaseDelay, + MaxDelay: config.ClickHouse.ChGo.GroupRetryMaxDelay, + }, ) if sErr != nil { return nil, fmt.Errorf( @@ -138,20 +160,47 @@ func New( topic: topic, stream: stream, }) + + metrics.OutputMaxInFlight().WithLabelValues(topic).Set(float64(topicKafkaCfg.MaxInFlight)) + } + + activeTopics := make(map[string]struct{}, len(topics)) + for _, t := range topics { + activeTopics[t] = struct{}{} + } + + if strings.TrimSpace(config.Kafka.RejectedTopic) == "" { + cLog.Warn("No rejectedTopic configured — decode errors and permanent write failures will block Kafka offset advancement (messages will be redelivered indefinitely). Configure kafka.rejectedTopic to enable dead letter queue") + } + + if len(config.Kafka.TopicOverrides) > 0 { + for overrideTopic := range config.Kafka.TopicOverrides { + if _, found := activeTopics[overrideTopic]; !found { + cLog.WithField("topic", overrideTopic). + Warn("Topic override configured but no matching topic was discovered — check for typos") + } + } } c := &Consumoor{ - log: cLog, - config: config, - metrics: metrics, - router: rtr, - writer: writer, - streams: streams, + log: cLog, + parentLog: log, + config: config, + metrics: metrics, + router: rtr, + writer: writer, + streams: streams, + activeTopics: activeTopics, } // Optionally create the Kafka consumer lag monitor. if config.Kafka.LagPollInterval > 0 { - lagMon, lagErr := source.NewLagMonitor(log, &config.Kafka, metrics) + lagMon, lagErr := source.NewLagMonitor( + log, + &config.Kafka, + consumerGroups, + metrics, + ) if lagErr != nil { return nil, fmt.Errorf("creating lag monitor: %w", lagErr) } @@ -168,7 +217,7 @@ func (c *Consumoor) Start(ctx context.Context) error { nctx, stop := signal.NotifyContext(ctx, syscall.SIGINT, syscall.SIGTERM) defer stop() - if err := c.writer.Start(ctx); err != nil { + if err := c.writer.Start(nctx); err != nil { return fmt.Errorf("starting clickhouse writer: %w", err) } @@ -217,7 +266,7 @@ func (c *Consumoor) Start(ctx context.Context) error { if c.config.Kafka.TopicRefreshInterval > 0 { g.Go(func() error { - c.watchTopics(gCtx) + c.watchTopics(gCtx, g) return nil }) @@ -228,7 +277,7 @@ func (c *Consumoor) Start(ctx context.Context) error { // All streams and HTTP servers have exited. Now stop the writer. c.stopWriter(ctx) - if streamErr != nil && streamErr != context.Canceled { + if streamErr != nil && !errors.Is(streamErr, context.Canceled) { return streamErr } @@ -237,20 +286,23 @@ func (c *Consumoor) Start(ctx context.Context) error { // stopHTTPServers shuts down the metrics and pprof servers. Called from // within the errgroup on context cancellation so that g.Wait() can return. -func (c *Consumoor) stopHTTPServers(ctx context.Context) { +func (c *Consumoor) stopHTTPServers(_ context.Context) { c.mu.Lock() metricsServer := c.metricsServer pprofServer := c.pprofServer c.mu.Unlock() + shutdownCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + if metricsServer != nil { - if err := metricsServer.Shutdown(ctx); err != nil { + if err := metricsServer.Shutdown(shutdownCtx); err != nil { c.log.WithError(err).Error("Error stopping metrics server") } } if pprofServer != nil { - if err := pprofServer.Shutdown(ctx); err != nil { + if err := pprofServer.Shutdown(shutdownCtx); err != nil { c.log.WithError(err).Error("Error stopping pprof server") } } @@ -335,17 +387,16 @@ func (c *Consumoor) startMetrics(ctx context.Context) error { } // watchTopics periodically queries Kafka metadata to discover topics matching -// the configured regex patterns. It logs newly appeared and disappeared topics -// and updates the active_topics gauge. The actual consumption of new topics is -// handled by Benthos via metadata_max_age; this goroutine provides visibility. -func (c *Consumoor) watchTopics(ctx context.Context) { +// the configured regex patterns. Newly discovered topics automatically get +// their own Benthos stream without requiring a restart. +func (c *Consumoor) watchTopics(ctx context.Context, g *errgroup.Group) { interval := c.config.Kafka.TopicRefreshInterval c.log.WithField("interval", interval). Info("Starting topic discovery watcher") // Perform an initial discovery so the metric is populated immediately. - knownTopics := c.discoverAndDiff(ctx, nil) + knownTopics := c.discoverAndDiff(ctx, g, nil) ticker := time.NewTicker(interval) defer ticker.Stop() @@ -357,16 +408,17 @@ func (c *Consumoor) watchTopics(ctx context.Context) { return case <-ticker.C: - knownTopics = c.discoverAndDiff(ctx, knownTopics) + knownTopics = c.discoverAndDiff(ctx, g, knownTopics) } } } // discoverAndDiff calls DiscoverTopics, compares the result to the previously -// known set, logs any changes, and updates the active_topics gauge. It returns -// the current set of discovered topics for the next comparison cycle. +// known set, logs any changes, updates the active_topics gauge, and starts +// streams for newly discovered topics. func (c *Consumoor) discoverAndDiff( ctx context.Context, + g *errgroup.Group, previous map[string]struct{}, ) map[string]struct{} { topics, err := source.DiscoverTopics(ctx, &c.config.Kafka) @@ -391,11 +443,12 @@ func (c *Consumoor) discoverAndDiff( return current } - // Find newly appeared topics. + // Find newly appeared topics and start streams for them. for _, t := range topics { if _, ok := previous[t]; !ok { c.log.WithField("topic", t). Info("Discovered new topic matching pattern") + c.startTopicStream(ctx, g, t) } } @@ -410,6 +463,85 @@ func (c *Consumoor) discoverAndDiff( return current } +// startTopicStream creates a Benthos stream for a dynamically discovered +// topic and launches it in the errgroup. If the topic already has an active +// stream, this is a no-op. +func (c *Consumoor) startTopicStream( + ctx context.Context, + g *errgroup.Group, + topic string, +) { + c.mu.Lock() + if _, exists := c.activeTopics[topic]; exists { + c.mu.Unlock() + + return + } + + c.activeTopics[topic] = struct{}{} + c.mu.Unlock() + + topicKafkaCfg := c.config.Kafka.ApplyTopicOverride(topic) + topicKafkaCfg.Topics = []string{"^" + regexp.QuoteMeta(topic) + "$"} + topicKafkaCfg.ConsumerGroup = c.config.Kafka.ConsumerGroup + "-" + topic + + if _, hasOverride := c.config.Kafka.TopicOverrides[topic]; hasOverride { + c.log.WithField("topic", topic). + WithField("outputBatchCount", topicKafkaCfg.OutputBatchCount). + WithField("outputBatchPeriod", topicKafkaCfg.OutputBatchPeriod). + WithField("maxInFlight", topicKafkaCfg.MaxInFlight). + Info("Applied per-topic batch overrides for dynamically discovered topic") + } + + stream, err := source.NewBenthosStream( + c.parentLog.WithField("topic", topic), + c.config.LoggingLevel, + &topicKafkaCfg, + c.metrics, + c.router, + c.writer, + false, // writer lifecycle owned by Consumoor + source.GroupRetryConfig{ + MaxAttempts: c.config.ClickHouse.ChGo.GroupRetryMaxAttempts, + BaseDelay: c.config.ClickHouse.ChGo.GroupRetryBaseDelay, + MaxDelay: c.config.ClickHouse.ChGo.GroupRetryMaxDelay, + }, + ) + if err != nil { + c.log.WithError(err). + WithField("topic", topic). + Error("Failed to create stream for dynamically discovered topic") + + c.mu.Lock() + delete(c.activeTopics, topic) + c.mu.Unlock() + + return + } + + c.mu.Lock() + c.streams = append(c.streams, topicStream{topic: topic, stream: stream}) + c.mu.Unlock() + + c.metrics.OutputMaxInFlight().WithLabelValues(topic).Set(float64(topicKafkaCfg.MaxInFlight)) + + c.log.WithField("topic", topic). + Info("Starting stream for dynamically discovered topic") + + if c.lagMonitor != nil { + c.log.WithField("topic", topic). + Warn("Dynamically discovered topic will not have consumer lag monitoring — restart to include it") + } + + g.Go(func() error { + if err := stream.Run(ctx); err != nil && !errors.Is(err, context.Canceled) { + return fmt.Errorf("running stream for topic %q: %w", topic, err) + } + + return nil + }) +} + func (c *Consumoor) startPProf(_ context.Context) error { c.log.WithField("addr", c.config.PProfAddr).Info("Starting pprof server") diff --git a/pkg/consumoor/health_test.go b/pkg/consumoor/health_test.go index 28f0fcc6d..7ef7785bf 100644 --- a/pkg/consumoor/health_test.go +++ b/pkg/consumoor/health_test.go @@ -8,6 +8,7 @@ import ( "net/http/httptest" "testing" + "github.com/ethpandaops/xatu/pkg/consumoor/clickhouse" "github.com/ethpandaops/xatu/pkg/proto/xatu" "github.com/sirupsen/logrus" "github.com/stretchr/testify/assert" @@ -19,12 +20,12 @@ type mockWriter struct { pingErr error } -func (m *mockWriter) Start(_ context.Context) error { return nil } -func (m *mockWriter) Stop(_ context.Context) error { return nil } -func (m *mockWriter) Write(_ string, _ *xatu.DecoratedEvent) {} -func (m *mockWriter) FlushAll(_ context.Context) error { return nil } -func (m *mockWriter) FlushTables(_ context.Context, _ []string) error { return nil } -func (m *mockWriter) Ping(_ context.Context) error { return m.pingErr } +func (m *mockWriter) Start(_ context.Context) error { return nil } +func (m *mockWriter) Stop(_ context.Context) error { return nil } +func (m *mockWriter) FlushTableEvents(_ context.Context, _ map[string][]*xatu.DecoratedEvent) *clickhouse.FlushResult { + return &clickhouse.FlushResult{} +} +func (m *mockWriter) Ping(_ context.Context) error { return m.pingErr } func TestHandleHealthz(t *testing.T) { c := &Consumoor{ diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_blob.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_blob.gen.go index e6f5c55dd..26e65126f 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_blob.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_blob.gen.go @@ -101,7 +101,7 @@ func (b *beaconApiEthV1BeaconBlobBatch) appendMetadata(event *xatu.DecoratedEven b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -112,10 +112,11 @@ func (b *beaconApiEthV1BeaconBlobBatch) appendMetadata(event *xatu.DecoratedEven b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_committee.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_committee.gen.go index f7d830e3e..9ec80ba11 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_committee.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_committee.gen.go @@ -95,7 +95,7 @@ func (b *beaconApiEthV1BeaconCommitteeBatch) appendMetadata(event *xatu.Decorate b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -106,10 +106,11 @@ func (b *beaconApiEthV1BeaconCommitteeBatch) appendMetadata(event *xatu.Decorate b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_committee.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_committee.go index d340dd289..6b9a3f159 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_committee.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_beacon_committee.go @@ -2,6 +2,7 @@ package beacon import ( "fmt" + "strconv" "strings" "time" @@ -92,7 +93,7 @@ func (b *beaconApiEthV1BeaconCommitteeBatch) appendPayload(event *xatu.Decorated } if committeeIndex := committee.GetIndex(); committeeIndex != nil { - b.CommitteeIndex.Append(fmt.Sprint(committeeIndex.GetValue())) + b.CommitteeIndex.Append(strconv.FormatUint(committeeIndex.GetValue(), 10)) } else { b.CommitteeIndex.Append("") } diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_attestation.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_attestation.gen.go index 27dc88d1e..6c6411e64 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_attestation.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_attestation.gen.go @@ -107,7 +107,7 @@ func (b *beaconApiEthV1EventsAttestationBatch) appendMetadata(event *xatu.Decora b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -118,10 +118,11 @@ func (b *beaconApiEthV1EventsAttestationBatch) appendMetadata(event *xatu.Decora b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_attestation.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_attestation.go index d29a35ad7..c2a055593 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_attestation.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_attestation.go @@ -2,6 +2,7 @@ package beacon import ( "fmt" + "strconv" "time" "github.com/ClickHouse/ch-go/proto" @@ -111,7 +112,7 @@ func (b *beaconApiEthV1EventsAttestationBatch) appendPayload(event *xatu.Decorat } if committeeIndex := data.GetIndex(); committeeIndex != nil { - b.CommitteeIndex.Append(fmt.Sprint(committeeIndex.GetValue())) + b.CommitteeIndex.Append(strconv.FormatUint(committeeIndex.GetValue(), 10)) } else { b.CommitteeIndex.Append("") } @@ -185,7 +186,7 @@ func (b *beaconApiEthV1EventsAttestationBatch) appendAdditionalData(event *xatu. } if ci := av.GetCommitteeIndex(); ci != nil { - b.AttestingValidatorCommitteeIndex.Append(fmt.Sprint(ci.GetValue())) + b.AttestingValidatorCommitteeIndex.Append(strconv.FormatUint(ci.GetValue(), 10)) } else { b.AttestingValidatorCommitteeIndex.Append("") } diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_blob_sidecar.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_blob_sidecar.gen.go index a9a5c43d6..ce023fe44 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_blob_sidecar.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_blob_sidecar.gen.go @@ -100,7 +100,7 @@ func (b *beaconApiEthV1EventsBlobSidecarBatch) appendMetadata(event *xatu.Decora b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -111,10 +111,11 @@ func (b *beaconApiEthV1EventsBlobSidecarBatch) appendMetadata(event *xatu.Decora b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_block.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_block.gen.go index 3eb8d9ae2..68e3a1ac3 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_block.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_block.gen.go @@ -96,7 +96,7 @@ func (b *beaconApiEthV1EventsBlockBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -107,10 +107,11 @@ func (b *beaconApiEthV1EventsBlockBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_block_gossip.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_block_gossip.gen.go index c1b75abd7..c2a71ea55 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_block_gossip.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_block_gossip.gen.go @@ -95,7 +95,7 @@ func (b *beaconApiEthV1EventsBlockGossipBatch) appendMetadata(event *xatu.Decora b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -106,10 +106,11 @@ func (b *beaconApiEthV1EventsBlockGossipBatch) appendMetadata(event *xatu.Decora b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_chain_reorg.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_chain_reorg.gen.go index 27e27c16b..bf5cf27c3 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_chain_reorg.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_chain_reorg.gen.go @@ -103,7 +103,7 @@ func (b *beaconApiEthV1EventsChainReorgBatch) appendMetadata(event *xatu.Decorat b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -114,10 +114,11 @@ func (b *beaconApiEthV1EventsChainReorgBatch) appendMetadata(event *xatu.Decorat b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_chain_reorg.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_chain_reorg.go index e5ffd27f0..d9e7dc446 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_chain_reorg.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_chain_reorg.go @@ -64,10 +64,6 @@ func (b *beaconApiEthV1EventsChainReorgBatch) validate(event *xatu.DecoratedEven return fmt.Errorf("nil Depth: %w", route.ErrInvalidEvent) } - if payload.GetEpoch() == nil { - return fmt.Errorf("nil Epoch: %w", route.ErrInvalidEvent) - } - return nil } @@ -99,13 +95,6 @@ func (b *beaconApiEthV1EventsChainReorgBatch) appendPayload(event *xatu.Decorate b.NewHeadBlock.Append([]byte(chainReorgV2.GetNewHeadBlock())) b.OldHeadState.Append([]byte(chainReorgV2.GetOldHeadState())) b.NewHeadState.Append([]byte(chainReorgV2.GetNewHeadState())) - - if epoch := chainReorgV2.GetEpoch(); epoch != nil { - b.Epoch.Append(uint32(epoch.GetValue())) //nolint:gosec // epoch fits uint32 - } else { - b.Epoch.Append(0) - } - b.ExecutionOptimistic.Append(false) } @@ -113,6 +102,7 @@ func (b *beaconApiEthV1EventsChainReorgBatch) appendAdditionalData(event *xatu.D if event.GetMeta() == nil || event.GetMeta().GetClient() == nil { b.SlotStartDateTime.Append(time.Time{}) b.PropagationSlotStartDiff.Append(0) + b.Epoch.Append(0) b.EpochStartDateTime.Append(time.Time{}) return @@ -123,5 +113,6 @@ func (b *beaconApiEthV1EventsChainReorgBatch) appendAdditionalData(event *xatu.D b.SlotStartDateTime.Append(time.Unix(additional.SlotStartDateTime, 0)) b.PropagationSlotStartDiff.Append(uint32(additional.PropagationSlotStartDiff)) //nolint:gosec // propagation diff fits uint32 + b.Epoch.Append(uint32(additional.Epoch)) //nolint:gosec // epoch fits uint32 b.EpochStartDateTime.Append(time.Unix(additional.EpochStartDateTime, 0)) } diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_contribution_and_proof.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_contribution_and_proof.gen.go index 2fdb44cec..640f147df 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_contribution_and_proof.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_contribution_and_proof.gen.go @@ -101,7 +101,7 @@ func (b *beaconApiEthV1EventsContributionAndProofBatch) appendMetadata(event *xa b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -112,10 +112,11 @@ func (b *beaconApiEthV1EventsContributionAndProofBatch) appendMetadata(event *xa b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_contribution_and_proof.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_contribution_and_proof.go index 542afa651..0323241ea 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_contribution_and_proof.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_contribution_and_proof.go @@ -2,6 +2,7 @@ package beacon import ( "fmt" + "strconv" "time" "github.com/ethpandaops/xatu/pkg/consumoor/route" @@ -131,7 +132,7 @@ func (b *beaconApiEthV1EventsContributionAndProofBatch) appendPayload(event *xat b.ContributionBeaconBlockRoot.Append([]byte(contribution.GetBeaconBlockRoot())) if subcommitteeIndex := contribution.GetSubcommitteeIndex(); subcommitteeIndex != nil { - b.ContributionSubcommitteeIndex.Append(fmt.Sprint(subcommitteeIndex.GetValue())) + b.ContributionSubcommitteeIndex.Append(strconv.FormatUint(subcommitteeIndex.GetValue(), 10)) } else { b.ContributionSubcommitteeIndex.Append("") } diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_data_column_sidecar.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_data_column_sidecar.gen.go index 66d0b46d6..e70b399a5 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_data_column_sidecar.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_data_column_sidecar.gen.go @@ -97,7 +97,7 @@ func (b *beaconApiEthV1EventsDataColumnSidecarBatch) appendMetadata(event *xatu. b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -108,10 +108,11 @@ func (b *beaconApiEthV1EventsDataColumnSidecarBatch) appendMetadata(event *xatu. b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_finalized_checkpoint.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_finalized_checkpoint.gen.go index b4d8a790d..b40e5adc7 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_finalized_checkpoint.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_finalized_checkpoint.gen.go @@ -95,7 +95,7 @@ func (b *beaconApiEthV1EventsFinalizedCheckpointBatch) appendMetadata(event *xat b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -106,10 +106,11 @@ func (b *beaconApiEthV1EventsFinalizedCheckpointBatch) appendMetadata(event *xat b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_head.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_head.gen.go index 5ded90783..03901ab47 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_head.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_head.gen.go @@ -101,7 +101,7 @@ func (b *beaconApiEthV1EventsHeadBatch) appendMetadata(event *xatu.DecoratedEven b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -112,10 +112,11 @@ func (b *beaconApiEthV1EventsHeadBatch) appendMetadata(event *xatu.DecoratedEven b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_voluntary_exit.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_voluntary_exit.gen.go index 5df6cd65f..0dbfd352c 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_voluntary_exit.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_events_voluntary_exit.gen.go @@ -96,7 +96,7 @@ func (b *beaconApiEthV1EventsVoluntaryExitBatch) appendMetadata(event *xatu.Deco b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -107,10 +107,11 @@ func (b *beaconApiEthV1EventsVoluntaryExitBatch) appendMetadata(event *xatu.Deco b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_proposer_duty.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_proposer_duty.gen.go index 6efe22649..ba8e9026f 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_proposer_duty.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_proposer_duty.gen.go @@ -94,7 +94,7 @@ func (b *beaconApiEthV1ProposerDutyBatch) appendMetadata(event *xatu.DecoratedEv b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -105,10 +105,11 @@ func (b *beaconApiEthV1ProposerDutyBatch) appendMetadata(event *xatu.DecoratedEv b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_validator_attestation_data.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_validator_attestation_data.gen.go index 30c9d6c53..e69e44bfe 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_validator_attestation_data.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_validator_attestation_data.gen.go @@ -106,7 +106,7 @@ func (b *beaconApiEthV1ValidatorAttestationDataBatch) appendMetadata(event *xatu b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -117,10 +117,11 @@ func (b *beaconApiEthV1ValidatorAttestationDataBatch) appendMetadata(event *xatu b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v1_validator_attestation_data.go b/pkg/consumoor/route/beacon/beacon_api_eth_v1_validator_attestation_data.go index ffe1e39ec..0a925ad29 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v1_validator_attestation_data.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v1_validator_attestation_data.go @@ -2,6 +2,7 @@ package beacon import ( "fmt" + "strconv" "time" "github.com/ethpandaops/xatu/pkg/consumoor/route" @@ -96,7 +97,7 @@ func (b *beaconApiEthV1ValidatorAttestationDataBatch) appendPayload(event *xatu. } if committeeIndex := attestationData.GetIndex(); committeeIndex != nil { - b.CommitteeIndex.Append(fmt.Sprint(committeeIndex.GetValue())) + b.CommitteeIndex.Append(strconv.FormatUint(committeeIndex.GetValue(), 10)) } else { b.CommitteeIndex.Append("") } diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v2_beacon_block.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v2_beacon_block.gen.go index 14e8ffede..09bc34591 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v2_beacon_block.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v2_beacon_block.gen.go @@ -132,7 +132,7 @@ func (b *beaconApiEthV2BeaconBlockBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -143,10 +143,11 @@ func (b *beaconApiEthV2BeaconBlockBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/beacon/beacon_api_eth_v3_validator_block.gen.go b/pkg/consumoor/route/beacon/beacon_api_eth_v3_validator_block.gen.go index 47240e048..eea9f1c3d 100644 --- a/pkg/consumoor/route/beacon/beacon_api_eth_v3_validator_block.gen.go +++ b/pkg/consumoor/route/beacon/beacon_api_eth_v3_validator_block.gen.go @@ -118,7 +118,7 @@ func (b *beaconApiEthV3ValidatorBlockBatch) appendMetadata(event *xatu.Decorated b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -129,10 +129,11 @@ func (b *beaconApiEthV3ValidatorBlockBatch) appendMetadata(event *xatu.Decorated b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar.gen.go index b69b1a61b..dd471da7e 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar.gen.go @@ -105,7 +105,7 @@ func (b *canonicalBeaconBlobSidecarBatch) appendMetadata(event *xatu.DecoratedEv b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -116,10 +116,11 @@ func (b *canonicalBeaconBlobSidecarBatch) appendMetadata(event *xatu.DecoratedEv b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar.go b/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar.go index 763af3959..d59b74217 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar.go @@ -76,11 +76,6 @@ func (b *canonicalBeaconBlobSidecarBatch) appendRuntime(_ *xatu.DecoratedEvent) func (b *canonicalBeaconBlobSidecarBatch) appendPayload(event *xatu.DecoratedEvent) { blob := event.GetEthV1BeaconBlockBlobSidecar() - if slot := blob.GetSlot(); slot != nil { - b.Slot.Append(uint32(slot.GetValue())) //nolint:gosec // G115 - } else { - b.Slot.Append(0) - } b.BlockRoot.Append([]byte(blob.GetBlockRoot())) b.BlockParentRoot.Append([]byte(blob.GetBlockParentRoot())) @@ -104,9 +99,10 @@ func (b *canonicalBeaconBlobSidecarBatch) appendPayload(event *xatu.DecoratedEve func (b *canonicalBeaconBlobSidecarBatch) appendAdditionalData(event *xatu.DecoratedEvent) { additional := event.GetMeta().GetClient().GetEthV1BeaconBlobSidecar() if additional == nil { + b.Slot.Append(0) + b.SlotStartDateTime.Append(time.Time{}) b.Epoch.Append(0) b.EpochStartDateTime.Append(time.Time{}) - b.SlotStartDateTime.Append(time.Time{}) b.VersionedHash.Append(nil) b.BlobSize.Append(0) b.BlobEmptySize.Append(proto.Nullable[uint32]{}) @@ -114,6 +110,23 @@ func (b *canonicalBeaconBlobSidecarBatch) appendAdditionalData(event *xatu.Decor return } + if slot := additional.GetSlot(); slot != nil { + if slotNumber := slot.GetNumber(); slotNumber != nil { + b.Slot.Append(uint32(slotNumber.GetValue())) //nolint:gosec // G115 + } else { + b.Slot.Append(0) + } + + if startDateTime := slot.GetStartDateTime(); startDateTime != nil { + b.SlotStartDateTime.Append(startDateTime.AsTime()) + } else { + b.SlotStartDateTime.Append(time.Time{}) + } + } else { + b.Slot.Append(0) + b.SlotStartDateTime.Append(time.Time{}) + } + if epoch := additional.GetEpoch(); epoch != nil { if epochNumber := epoch.GetNumber(); epochNumber != nil { b.Epoch.Append(uint32(epochNumber.GetValue())) //nolint:gosec // G115 @@ -131,16 +144,6 @@ func (b *canonicalBeaconBlobSidecarBatch) appendAdditionalData(event *xatu.Decor b.EpochStartDateTime.Append(time.Time{}) } - if slot := additional.GetSlot(); slot != nil { - if startDateTime := slot.GetStartDateTime(); startDateTime != nil { - b.SlotStartDateTime.Append(startDateTime.AsTime()) - } else { - b.SlotStartDateTime.Append(time.Time{}) - } - } else { - b.SlotStartDateTime.Append(time.Time{}) - } - b.VersionedHash.Append([]byte(additional.GetVersionedHash())) if dataSize := additional.GetDataSize(); dataSize != nil { diff --git a/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar_test.go b/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar_test.go index 52a166bc5..f89f1d561 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar_test.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_blob_sidecar_test.go @@ -19,6 +19,7 @@ func TestSnapshot_canonical_beacon_blob_sidecar(t *testing.T) { Meta: testfixture.MetaWithAdditional(&xatu.ClientMeta{ AdditionalData: &xatu.ClientMeta_EthV1BeaconBlobSidecar{ EthV1BeaconBlobSidecar: &xatu.ClientMeta_AdditionalEthV1BeaconBlobSidecarData{ + Slot: testfixture.SlotEpochAdditional(), Epoch: testfixture.EpochAdditional(), }, }, diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block.gen.go index 421b8281c..d145f5a5e 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block.gen.go @@ -132,7 +132,7 @@ func (b *canonicalBeaconBlockBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -143,10 +143,11 @@ func (b *canonicalBeaconBlockBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_attester_slashing.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block_attester_slashing.gen.go index 3b07a949d..81e2ef4da 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_attester_slashing.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_attester_slashing.gen.go @@ -119,7 +119,7 @@ func (b *canonicalBeaconBlockAttesterSlashingBatch) appendMetadata(event *xatu.D b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -130,10 +130,11 @@ func (b *canonicalBeaconBlockAttesterSlashingBatch) appendMetadata(event *xatu.D b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_bls_to_execution_change.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block_bls_to_execution_change.gen.go index d6beb6382..cad963a71 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_bls_to_execution_change.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_bls_to_execution_change.gen.go @@ -98,7 +98,7 @@ func (b *canonicalBeaconBlockBlsToExecutionChangeBatch) appendMetadata(event *xa b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -109,10 +109,11 @@ func (b *canonicalBeaconBlockBlsToExecutionChangeBatch) appendMetadata(event *xa b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_deposit.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block_deposit.gen.go index ec7c96d58..cffd4cc38 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_deposit.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_deposit.gen.go @@ -100,7 +100,7 @@ func (b *canonicalBeaconBlockDepositBatch) appendMetadata(event *xatu.DecoratedE b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -111,10 +111,11 @@ func (b *canonicalBeaconBlockDepositBatch) appendMetadata(event *xatu.DecoratedE b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_deposit.go b/pkg/consumoor/route/canonical/canonical_beacon_block_deposit.go index 557f120c6..d36a5d34a 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_deposit.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_deposit.go @@ -2,6 +2,7 @@ package canonical import ( "fmt" + "strconv" "time" "github.com/ethpandaops/xatu/pkg/consumoor/route" @@ -65,7 +66,7 @@ func (b *canonicalBeaconBlockDepositBatch) appendPayload(event *xatu.DecoratedEv b.DepositDataSignature.Append(data.GetSignature()) if amount := data.GetAmount(); amount != nil { - parsedAmount, err := route.ParseUInt128(fmt.Sprintf("%d", amount.GetValue())) + parsedAmount, err := route.ParseUInt128(strconv.FormatUint(amount.GetValue(), 10)) if err != nil { return fmt.Errorf("parsing deposit_data_amount: %w", err) } diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_execution_transaction.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block_execution_transaction.gen.go index 106e60ce2..2178a7735 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_execution_transaction.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_execution_transaction.gen.go @@ -121,7 +121,7 @@ func (b *canonicalBeaconBlockExecutionTransactionBatch) appendMetadata(event *xa b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -132,10 +132,11 @@ func (b *canonicalBeaconBlockExecutionTransactionBatch) appendMetadata(event *xa b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_proposer_slashing.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block_proposer_slashing.gen.go index ac985c017..f3bc9d3ec 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_proposer_slashing.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_proposer_slashing.gen.go @@ -111,7 +111,7 @@ func (b *canonicalBeaconBlockProposerSlashingBatch) appendMetadata(event *xatu.D b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -122,10 +122,11 @@ func (b *canonicalBeaconBlockProposerSlashingBatch) appendMetadata(event *xatu.D b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_sync_aggregate.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block_sync_aggregate.gen.go index 178901322..35c1436a8 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_sync_aggregate.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_sync_aggregate.gen.go @@ -103,7 +103,7 @@ func (b *canonicalBeaconBlockSyncAggregateBatch) appendMetadata(event *xatu.Deco b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -114,10 +114,11 @@ func (b *canonicalBeaconBlockSyncAggregateBatch) appendMetadata(event *xatu.Deco b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_voluntary_exit.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block_voluntary_exit.gen.go index a3e923965..67b6e6f5c 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_voluntary_exit.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_voluntary_exit.gen.go @@ -96,7 +96,7 @@ func (b *canonicalBeaconBlockVoluntaryExitBatch) appendMetadata(event *xatu.Deco b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -107,10 +107,11 @@ func (b *canonicalBeaconBlockVoluntaryExitBatch) appendMetadata(event *xatu.Deco b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_withdrawal.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_block_withdrawal.gen.go index 708ff3527..c4a01ff69 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_withdrawal.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_withdrawal.gen.go @@ -98,7 +98,7 @@ func (b *canonicalBeaconBlockWithdrawalBatch) appendMetadata(event *xatu.Decorat b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -109,10 +109,11 @@ func (b *canonicalBeaconBlockWithdrawalBatch) appendMetadata(event *xatu.Decorat b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_block_withdrawal.go b/pkg/consumoor/route/canonical/canonical_beacon_block_withdrawal.go index a390ccf4c..4558630e9 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_block_withdrawal.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_block_withdrawal.go @@ -2,6 +2,7 @@ package canonical import ( "fmt" + "strconv" "time" "github.com/ethpandaops/xatu/pkg/consumoor/route" @@ -95,7 +96,7 @@ func (b *canonicalBeaconBlockWithdrawalBatch) appendPayload(event *xatu.Decorate } if amount := withdrawal.GetAmount(); amount != nil { - parsedAmount, err := route.ParseUInt128(fmt.Sprintf("%d", amount.GetValue())) + parsedAmount, err := route.ParseUInt128(strconv.FormatUint(amount.GetValue(), 10)) if err != nil { return fmt.Errorf("parsing withdrawal_amount: %w", err) } diff --git a/pkg/consumoor/route/canonical/canonical_beacon_committee.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_committee.gen.go index 4033d32e3..d5e7fd46e 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_committee.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_committee.gen.go @@ -93,7 +93,7 @@ func (b *canonicalBeaconCommitteeBatch) appendMetadata(event *xatu.DecoratedEven b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -104,10 +104,11 @@ func (b *canonicalBeaconCommitteeBatch) appendMetadata(event *xatu.DecoratedEven b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_committee.go b/pkg/consumoor/route/canonical/canonical_beacon_committee.go index f7510e8c3..31b5344d5 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_committee.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_committee.go @@ -2,6 +2,7 @@ package canonical import ( "fmt" + "strconv" "strings" "time" @@ -65,8 +66,15 @@ func (b *canonicalBeaconCommitteeBatch) appendRuntime(_ *xatu.DecoratedEvent) { func (b *canonicalBeaconCommitteeBatch) appendPayload(event *xatu.DecoratedEvent) { committee := event.GetEthV1BeaconCommittee() + + if slot := committee.GetSlot(); slot != nil { + b.Slot.Append(uint32(slot.GetValue())) //nolint:gosec // G115 + } else { + b.Slot.Append(0) + } + if index := committee.GetIndex(); index != nil { - b.CommitteeIndex.Append(fmt.Sprintf("%d", index.GetValue())) + b.CommitteeIndex.Append(strconv.FormatUint(index.GetValue(), 10)) } else { b.CommitteeIndex.Append("") } @@ -78,7 +86,6 @@ func (b *canonicalBeaconCommitteeBatch) appendPayload(event *xatu.DecoratedEvent func (b *canonicalBeaconCommitteeBatch) appendAdditionalData(event *xatu.DecoratedEvent) { additional := event.GetMeta().GetClient().GetEthV1BeaconCommittee() if additional == nil { - b.Slot.Append(0) b.SlotStartDateTime.Append(time.Time{}) b.Epoch.Append(0) b.EpochStartDateTime.Append(time.Time{}) @@ -86,6 +93,16 @@ func (b *canonicalBeaconCommitteeBatch) appendAdditionalData(event *xatu.Decorat return } + if slotData := additional.GetSlot(); slotData != nil { + if startDateTime := slotData.GetStartDateTime(); startDateTime != nil { + b.SlotStartDateTime.Append(startDateTime.AsTime()) + } else { + b.SlotStartDateTime.Append(time.Time{}) + } + } else { + b.SlotStartDateTime.Append(time.Time{}) + } + if epochData := additional.GetEpoch(); epochData != nil { if epochNumber := epochData.GetNumber(); epochNumber != nil { b.Epoch.Append(uint32(epochNumber.GetValue())) @@ -102,21 +119,4 @@ func (b *canonicalBeaconCommitteeBatch) appendAdditionalData(event *xatu.Decorat b.Epoch.Append(0) b.EpochStartDateTime.Append(time.Time{}) } - - if slotData := additional.GetSlot(); slotData != nil { - if slotNumber := slotData.GetNumber(); slotNumber != nil { - b.Slot.Append(uint32(slotNumber.GetValue())) - } else { - b.Slot.Append(0) - } - - if startDateTime := slotData.GetStartDateTime(); startDateTime != nil { - b.SlotStartDateTime.Append(startDateTime.AsTime()) - } else { - b.SlotStartDateTime.Append(time.Time{}) - } - } else { - b.Slot.Append(0) - b.SlotStartDateTime.Append(time.Time{}) - } } diff --git a/pkg/consumoor/route/canonical/canonical_beacon_elaborated_attestation.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_elaborated_attestation.gen.go index 3a70daf19..2abaca7a5 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_elaborated_attestation.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_elaborated_attestation.gen.go @@ -110,7 +110,7 @@ func (b *canonicalBeaconElaboratedAttestationBatch) appendMetadata(event *xatu.D b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -121,10 +121,11 @@ func (b *canonicalBeaconElaboratedAttestationBatch) appendMetadata(event *xatu.D b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_elaborated_attestation.go b/pkg/consumoor/route/canonical/canonical_beacon_elaborated_attestation.go index 738af99de..38beb0cb6 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_elaborated_attestation.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_elaborated_attestation.go @@ -1,7 +1,7 @@ package canonical import ( - "fmt" + "strconv" "time" "github.com/ethpandaops/xatu/pkg/consumoor/route" @@ -61,7 +61,7 @@ func (b *canonicalBeaconElaboratedAttestationBatch) appendRow(event *xatu.Decora b.BeaconBlockRoot.Append([]byte(data.GetBeaconBlockRoot())) if index := data.GetIndex(); index != nil { - b.CommitteeIndex.Append(fmt.Sprintf("%d", index.GetValue())) + b.CommitteeIndex.Append(strconv.FormatUint(index.GetValue(), 10)) } else { b.CommitteeIndex.Append("") } @@ -109,7 +109,18 @@ func (b *canonicalBeaconElaboratedAttestationBatch) appendRow(event *xatu.Decora b.TargetRoot.Append(nil) } - // Additional data fields (including Slot which overrides the payload slot). + // Slot from payload (matching Vector: .slot = .data.data.slot). + if attestation != nil && attestation.GetData() != nil { + if slot := attestation.GetData().GetSlot(); slot != nil { + b.Slot.Append(uint32(slot.GetValue())) + } else { + b.Slot.Append(0) + } + } else { + b.Slot.Append(0) + } + + // Additional data fields. additional := event.GetMeta().GetClient().GetEthV2BeaconBlockElaboratedAttestation() if additional == nil { b.BlockSlot.Append(0) @@ -118,7 +129,6 @@ func (b *canonicalBeaconElaboratedAttestationBatch) appendRow(event *xatu.Decora b.BlockEpochStartDateTime.Append(time.Time{}) b.BlockRoot.Append(nil) b.PositionInBlock.Append(0) - b.Slot.Append(0) b.SlotStartDateTime.Append(time.Time{}) b.Epoch.Append(0) b.EpochStartDateTime.Append(time.Time{}) @@ -137,6 +147,16 @@ func (b *canonicalBeaconElaboratedAttestationBatch) appendRow(event *xatu.Decora b.PositionInBlock.Append(0) } + if slotData := additional.GetSlot(); slotData != nil { + if startDateTime := slotData.GetStartDateTime(); startDateTime != nil { + b.SlotStartDateTime.Append(startDateTime.AsTime()) + } else { + b.SlotStartDateTime.Append(time.Time{}) + } + } else { + b.SlotStartDateTime.Append(time.Time{}) + } + if epochData := additional.GetEpoch(); epochData != nil { if epochNumber := epochData.GetNumber(); epochNumber != nil { b.Epoch.Append(uint32(epochNumber.GetValue())) @@ -154,23 +174,6 @@ func (b *canonicalBeaconElaboratedAttestationBatch) appendRow(event *xatu.Decora b.EpochStartDateTime.Append(time.Time{}) } - if slotData := additional.GetSlot(); slotData != nil { - if slotNumber := slotData.GetNumber(); slotNumber != nil { - b.Slot.Append(uint32(slotNumber.GetValue())) - } else { - b.Slot.Append(0) - } - - if startDateTime := slotData.GetStartDateTime(); startDateTime != nil { - b.SlotStartDateTime.Append(startDateTime.AsTime()) - } else { - b.SlotStartDateTime.Append(time.Time{}) - } - } else { - b.Slot.Append(0) - b.SlotStartDateTime.Append(time.Time{}) - } - if source := additional.GetSource(); source != nil { if sourceEpoch := source.GetEpoch(); sourceEpoch != nil { if startDateTime := sourceEpoch.GetStartDateTime(); startDateTime != nil { diff --git a/pkg/consumoor/route/canonical/canonical_beacon_proposer_duty.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_proposer_duty.gen.go index 783479989..7417cbb00 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_proposer_duty.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_proposer_duty.gen.go @@ -92,7 +92,7 @@ func (b *canonicalBeaconProposerDutyBatch) appendMetadata(event *xatu.DecoratedE b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -103,10 +103,11 @@ func (b *canonicalBeaconProposerDutyBatch) appendMetadata(event *xatu.DecoratedE b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_sync_committee.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_sync_committee.gen.go index 12023f4a4..8133e591b 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_sync_committee.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_sync_committee.gen.go @@ -93,7 +93,7 @@ func (b *canonicalBeaconSyncCommitteeBatch) appendMetadata(event *xatu.Decorated b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -104,10 +104,11 @@ func (b *canonicalBeaconSyncCommitteeBatch) appendMetadata(event *xatu.Decorated b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_validators.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_validators.gen.go index 406f9d923..f271bcdb5 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_validators.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_validators.gen.go @@ -103,7 +103,7 @@ func (b *canonicalBeaconValidatorsBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -114,10 +114,11 @@ func (b *canonicalBeaconValidatorsBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_validators_pubkeys.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_validators_pubkeys.gen.go index 0fad0203f..ecaf43c84 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_validators_pubkeys.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_validators_pubkeys.gen.go @@ -91,7 +91,7 @@ func (b *canonicalBeaconValidatorsPubkeysBatch) appendMetadata(event *xatu.Decor b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -102,10 +102,11 @@ func (b *canonicalBeaconValidatorsPubkeysBatch) appendMetadata(event *xatu.Decor b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/canonical/canonical_beacon_validators_withdrawal_credentials.gen.go b/pkg/consumoor/route/canonical/canonical_beacon_validators_withdrawal_credentials.gen.go index 49b12616c..aed0b34da 100644 --- a/pkg/consumoor/route/canonical/canonical_beacon_validators_withdrawal_credentials.gen.go +++ b/pkg/consumoor/route/canonical/canonical_beacon_validators_withdrawal_credentials.gen.go @@ -91,7 +91,7 @@ func (b *canonicalBeaconValidatorsWithdrawalCredentialsBatch) appendMetadata(eve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) @@ -102,10 +102,11 @@ func (b *canonicalBeaconValidatorsWithdrawalCredentialsBatch) appendMetadata(eve b.MetaClientGeoAutonomousSystemOrganization.Append(proto.NewNullable[string](event.GetMeta().GetServer().GetClient().GetGeo().GetAutonomousSystemOrganization())) b.MetaNetworkID.Append(int32(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetId())) b.MetaNetworkName.Append(event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName()) - b.MetaConsensusVersion.Append(route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMajor.Append(route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionMinor.Append(route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) - b.MetaConsensusVersionPatch.Append(route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())) + cvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion()) + b.MetaConsensusVersion.Append(cvNorm) + b.MetaConsensusVersionMajor.Append(cvMajor) + b.MetaConsensusVersionMinor.Append(cvMinor) + b.MetaConsensusVersionPatch.Append(cvPatch) b.MetaConsensusImplementation.Append(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()) if labels := event.GetMeta().GetClient().GetLabels(); labels != nil { b.MetaLabels.Append(labels) diff --git a/pkg/consumoor/route/cmd/chgo-rowgen/main.go b/pkg/consumoor/route/cmd/chgo-rowgen/main.go index 52ae1aa7e..2beebcff7 100644 --- a/pkg/consumoor/route/cmd/chgo-rowgen/main.go +++ b/pkg/consumoor/route/cmd/chgo-rowgen/main.go @@ -1005,8 +1005,8 @@ var metaColumnDefs = map[string]metaColumnDef{ "meta_client_clock_drift": {expr: "event.GetMeta().GetClient().GetClockDrift()", goType: goTypeUint64}, "meta_client_module_name": {expr: "event.GetMeta().GetClient().GetModuleName().String()"}, - // Client IP (normalized to IPv6 in a single parse) - "meta_client_ip": {expr: "route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP())", goType: protoIPv6}, + // Client IP (nullable – NULL when empty/unparseable, matching Vector behavior) + "meta_client_ip": {special: "nullable_ip"}, // Client geo "meta_client_geo_city": {expr: "event.GetMeta().GetServer().GetClient().GetGeo().GetCity()"}, @@ -1024,10 +1024,10 @@ var metaColumnDefs = map[string]metaColumnDef{ // Consensus client "meta_consensus_implementation": {expr: "event.GetMeta().GetClient().GetEthereum().GetConsensus().GetImplementation()"}, - "meta_consensus_version": {expr: "route.NormalizeConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())"}, - "meta_consensus_version_major": {expr: "route.ConsensusVersionMajor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())"}, - "meta_consensus_version_minor": {expr: "route.ConsensusVersionMinor(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())"}, - "meta_consensus_version_patch": {expr: "route.ConsensusVersionPatch(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())"}, + "meta_consensus_version": {special: "consensus_version_normalized"}, + "meta_consensus_version_major": {special: "consensus_version_major"}, + "meta_consensus_version_minor": {special: "consensus_version_minor"}, + "meta_consensus_version_patch": {special: "consensus_version_patch"}, // Execution client "meta_execution_implementation": {expr: "event.GetMeta().GetClient().GetEthereum().GetExecution().GetImplementation()"}, @@ -1059,6 +1059,26 @@ func writeAppendMetadata(b *bytes.Buffer, batchName string, cols []column, gens b.WriteString("\t}\n\n") // Non-nil case: append from proto getters. + // + // Emit a single ParseConsensusVersion call if any of the four + // consensus_version columns are present, so the version string is + // parsed once instead of four separate times per event. + cvEmitted := false + cvFieldMap := map[string]string{ + "consensus_version_normalized": "", + "consensus_version_major": "", + "consensus_version_minor": "", + "consensus_version_patch": "", + } + + for _, col := range cols { + if def, ok := metaColumnDefs[col.Name]; ok { + if _, isCv := cvFieldMap[def.special]; isCv { + cvFieldMap[def.special] = col.Field + } + } + } + for i, col := range cols { if !strings.HasPrefix(col.Name, "meta_") { continue @@ -1085,6 +1105,40 @@ func writeAppendMetadata(b *bytes.Buffer, batchName string, cols []column, gens continue } + // Special handling for nullable IP (NULL when empty/unparseable). + if def.special == "nullable_ip" { + fmt.Fprintf(b, "\tb.%s.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP()))\n", col.Field) + + continue + } + + // Consensus version columns: emit the single parse call on + // first encounter, then reference the local variables. + if _, isCv := cvFieldMap[def.special]; isCv { + if !cvEmitted { + b.WriteString("\tcvNorm, cvMajor, cvMinor, cvPatch := route.ParseConsensusVersion(event.GetMeta().GetClient().GetEthereum().GetConsensus().GetVersion())\n") + + cvEmitted = true + } + + var localVar string + + switch def.special { + case "consensus_version_normalized": + localVar = "cvNorm" + case "consensus_version_major": + localVar = "cvMajor" + case "consensus_version_minor": + localVar = "cvMinor" + case "consensus_version_patch": + localVar = "cvPatch" + } + + fmt.Fprintf(b, "\tb.%s.Append(%s)\n", col.Field, localVar) + + continue + } + expr := metaAppendExpr(&gen, def) fmt.Fprintf(b, "\tb.%s.Append(%s)\n", col.Field, expr) } diff --git a/pkg/consumoor/route/column.go b/pkg/consumoor/route/column.go index 5312a7f6f..e63049cef 100644 --- a/pkg/consumoor/route/column.go +++ b/pkg/consumoor/route/column.go @@ -32,6 +32,26 @@ func NormalizeIPToIPv6(raw string) proto.IPv6 { return proto.ToIPv6(addr) } +// NormalizeIPToIPv6Nullable parses an IP string and returns a Nullable IPv6. +// Returns NULL when the input is empty or unparseable (matching Vector behavior), +// rather than writing the zero address "::". +func NormalizeIPToIPv6Nullable(raw string) proto.Nullable[proto.IPv6] { + if raw == "" { + return proto.Nullable[proto.IPv6]{} + } + + addr, err := netip.ParseAddr(raw) + if err != nil { + return proto.Nullable[proto.IPv6]{} + } + + if addr.Is4() { + addr = netip.AddrFrom16(addr.As16()) + } + + return proto.NewNullable[proto.IPv6](proto.ToIPv6(addr)) +} + // NormalizeConsensusVersion strips the implementation prefix from a // consensus version string (e.g. "Lighthouse/v4.5.0" -> "v4.5.0"). func NormalizeConsensusVersion(raw string) string { @@ -71,12 +91,13 @@ func ConsensusVersionPatch(raw string) string { return patch } -// parseConsensusVersion normalizes and splits a consensus version string -// into major, minor, patch components. -func parseConsensusVersion(raw string) (major, minor, patch string) { - normalized := NormalizeConsensusVersion(raw) +// ParseConsensusVersion normalizes a raw consensus version string and +// splits it into its four components in a single pass. +// This avoids repeated SplitN calls when each component is needed. +func ParseConsensusVersion(raw string) (normalized, major, minor, patch string) { + normalized = NormalizeConsensusVersion(raw) if normalized == "" { - return "", "", "" + return "", "", "", "" } version := strings.TrimPrefix(normalized, "v") @@ -99,6 +120,14 @@ func parseConsensusVersion(raw string) (major, minor, patch string) { } } + return normalized, major, minor, patch +} + +// parseConsensusVersion normalizes and splits a consensus version string +// into major, minor, patch components. +func parseConsensusVersion(raw string) (major, minor, patch string) { + _, major, minor, patch = ParseConsensusVersion(raw) + return major, minor, patch } diff --git a/pkg/consumoor/route/execution/consensus_engine_api_get_blobs.gen.go b/pkg/consumoor/route/execution/consensus_engine_api_get_blobs.gen.go index b09a4013e..7ca229f8d 100644 --- a/pkg/consumoor/route/execution/consensus_engine_api_get_blobs.gen.go +++ b/pkg/consumoor/route/execution/consensus_engine_api_get_blobs.gen.go @@ -113,7 +113,7 @@ func (b *consensusEngineApiGetBlobsBatch) appendMetadata(event *xatu.DecoratedEv b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/execution/consensus_engine_api_new_payload.gen.go b/pkg/consumoor/route/execution/consensus_engine_api_new_payload.gen.go index 93c631e67..aa297d61b 100644 --- a/pkg/consumoor/route/execution/consensus_engine_api_new_payload.gen.go +++ b/pkg/consumoor/route/execution/consensus_engine_api_new_payload.gen.go @@ -117,7 +117,7 @@ func (b *consensusEngineApiNewPayloadBatch) appendMetadata(event *xatu.Decorated b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/execution/execution_block_metrics.gen.go b/pkg/consumoor/route/execution/execution_block_metrics.gen.go index a7a049546..ac347530b 100644 --- a/pkg/consumoor/route/execution/execution_block_metrics.gen.go +++ b/pkg/consumoor/route/execution/execution_block_metrics.gen.go @@ -111,7 +111,7 @@ func (b *executionBlockMetricsBatch) appendMetadata(event *xatu.DecoratedEvent) b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/execution/execution_engine_get_blobs.gen.go b/pkg/consumoor/route/execution/execution_engine_get_blobs.gen.go index 4762cd1ca..704da51c6 100644 --- a/pkg/consumoor/route/execution/execution_engine_get_blobs.gen.go +++ b/pkg/consumoor/route/execution/execution_engine_get_blobs.gen.go @@ -108,7 +108,7 @@ func (b *executionEngineGetBlobsBatch) appendMetadata(event *xatu.DecoratedEvent b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/execution/execution_engine_new_payload.gen.go b/pkg/consumoor/route/execution/execution_engine_new_payload.gen.go index da77efca1..3ed09116d 100644 --- a/pkg/consumoor/route/execution/execution_engine_new_payload.gen.go +++ b/pkg/consumoor/route/execution/execution_engine_new_payload.gen.go @@ -109,7 +109,7 @@ func (b *executionEngineNewPayloadBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/execution/execution_state_size.gen.go b/pkg/consumoor/route/execution/execution_state_size.gen.go index bfcbdd73e..d01f4a531 100644 --- a/pkg/consumoor/route/execution/execution_state_size.gen.go +++ b/pkg/consumoor/route/execution/execution_state_size.gen.go @@ -101,7 +101,7 @@ func (b *executionStateSizeBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/execution/mempool_transaction.gen.go b/pkg/consumoor/route/execution/mempool_transaction.gen.go index 2ed3095a7..e4a98230e 100644 --- a/pkg/consumoor/route/execution/mempool_transaction.gen.go +++ b/pkg/consumoor/route/execution/mempool_transaction.gen.go @@ -110,7 +110,7 @@ func (b *mempoolTransactionBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_add_peer.gen.go b/pkg/consumoor/route/libp2p/libp2p_add_peer.gen.go index 2f8052ade..34a195f5d 100644 --- a/pkg/consumoor/route/libp2p/libp2p_add_peer.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_add_peer.gen.go @@ -77,7 +77,7 @@ func (b *libp2pAddPeerBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_connected.gen.go b/pkg/consumoor/route/libp2p/libp2p_connected.gen.go index b677c09b1..bcd9bb9f8 100644 --- a/pkg/consumoor/route/libp2p/libp2p_connected.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_connected.gen.go @@ -102,7 +102,7 @@ func (b *libp2pConnectedBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_deliver_message.gen.go b/pkg/consumoor/route/libp2p/libp2p_deliver_message.gen.go index a761ba3e0..23776db1b 100644 --- a/pkg/consumoor/route/libp2p/libp2p_deliver_message.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_deliver_message.gen.go @@ -84,7 +84,7 @@ func (b *libp2pDeliverMessageBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_disconnected.gen.go b/pkg/consumoor/route/libp2p/libp2p_disconnected.gen.go index 28413184b..c41ee1c66 100644 --- a/pkg/consumoor/route/libp2p/libp2p_disconnected.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_disconnected.gen.go @@ -102,7 +102,7 @@ func (b *libp2pDisconnectedBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_drop_rpc.gen.go b/pkg/consumoor/route/libp2p/libp2p_drop_rpc.gen.go index 89f5a2838..d85ec967b 100644 --- a/pkg/consumoor/route/libp2p/libp2p_drop_rpc.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_drop_rpc.gen.go @@ -77,7 +77,7 @@ func (b *libp2pDropRpcBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_duplicate_message.gen.go b/pkg/consumoor/route/libp2p/libp2p_duplicate_message.gen.go index 095c5b6ae..67b60b94b 100644 --- a/pkg/consumoor/route/libp2p/libp2p_duplicate_message.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_duplicate_message.gen.go @@ -84,7 +84,7 @@ func (b *libp2pDuplicateMessageBatch) appendMetadata(event *xatu.DecoratedEvent) b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_gossipsub_aggregate_and_proof.gen.go b/pkg/consumoor/route/libp2p/libp2p_gossipsub_aggregate_and_proof.gen.go index a2a080932..03529a330 100644 --- a/pkg/consumoor/route/libp2p/libp2p_gossipsub_aggregate_and_proof.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_gossipsub_aggregate_and_proof.gen.go @@ -103,7 +103,7 @@ func (b *libp2pGossipsubAggregateAndProofBatch) appendMetadata(event *xatu.Decor b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_gossipsub_beacon_attestation.gen.go b/pkg/consumoor/route/libp2p/libp2p_gossipsub_beacon_attestation.gen.go index df584e6a7..365693edb 100644 --- a/pkg/consumoor/route/libp2p/libp2p_gossipsub_beacon_attestation.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_gossipsub_beacon_attestation.gen.go @@ -107,7 +107,7 @@ func (b *libp2pGossipsubBeaconAttestationBatch) appendMetadata(event *xatu.Decor b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_gossipsub_beacon_block.gen.go b/pkg/consumoor/route/libp2p/libp2p_gossipsub_beacon_block.gen.go index 03f19172f..74cfd4ba5 100644 --- a/pkg/consumoor/route/libp2p/libp2p_gossipsub_beacon_block.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_gossipsub_beacon_block.gen.go @@ -95,7 +95,7 @@ func (b *libp2pGossipsubBeaconBlockBatch) appendMetadata(event *xatu.DecoratedEv b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_gossipsub_blob_sidecar.gen.go b/pkg/consumoor/route/libp2p/libp2p_gossipsub_blob_sidecar.gen.go index 52536877a..315e791db 100644 --- a/pkg/consumoor/route/libp2p/libp2p_gossipsub_blob_sidecar.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_gossipsub_blob_sidecar.gen.go @@ -100,7 +100,7 @@ func (b *libp2pGossipsubBlobSidecarBatch) appendMetadata(event *xatu.DecoratedEv b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_gossipsub_data_column_sidecar.gen.go b/pkg/consumoor/route/libp2p/libp2p_gossipsub_data_column_sidecar.gen.go index c419a6714..d4fab0930 100644 --- a/pkg/consumoor/route/libp2p/libp2p_gossipsub_data_column_sidecar.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_gossipsub_data_column_sidecar.gen.go @@ -101,7 +101,7 @@ func (b *libp2pGossipsubDataColumnSidecarBatch) appendMetadata(event *xatu.Decor b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_graft.gen.go b/pkg/consumoor/route/libp2p/libp2p_graft.gen.go index b90754858..f229fdb01 100644 --- a/pkg/consumoor/route/libp2p/libp2p_graft.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_graft.gen.go @@ -80,7 +80,7 @@ func (b *libp2pGraftBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_handle_metadata.gen.go b/pkg/consumoor/route/libp2p/libp2p_handle_metadata.gen.go index 7fbde4bf3..9da3d1c05 100644 --- a/pkg/consumoor/route/libp2p/libp2p_handle_metadata.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_handle_metadata.gen.go @@ -87,7 +87,7 @@ func (b *libp2pHandleMetadataBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_handle_status.gen.go b/pkg/consumoor/route/libp2p/libp2p_handle_status.gen.go index ff2cfad41..ddb782b37 100644 --- a/pkg/consumoor/route/libp2p/libp2p_handle_status.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_handle_status.gen.go @@ -104,7 +104,7 @@ func (b *libp2pHandleStatusBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_identify.gen.go b/pkg/consumoor/route/libp2p/libp2p_identify.gen.go index 715033301..26d1c2833 100644 --- a/pkg/consumoor/route/libp2p/libp2p_identify.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_identify.gen.go @@ -113,7 +113,7 @@ func (b *libp2pIdentifyBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_join.gen.go b/pkg/consumoor/route/libp2p/libp2p_join.gen.go index 5e6fbe70e..3de919e0c 100644 --- a/pkg/consumoor/route/libp2p/libp2p_join.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_join.gen.go @@ -80,7 +80,7 @@ func (b *libp2pJoinBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_leave.gen.go b/pkg/consumoor/route/libp2p/libp2p_leave.gen.go index 67cb64edc..2a3a39b29 100644 --- a/pkg/consumoor/route/libp2p/libp2p_leave.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_leave.gen.go @@ -80,7 +80,7 @@ func (b *libp2pLeaveBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_prune.gen.go b/pkg/consumoor/route/libp2p/libp2p_prune.gen.go index 00d965558..30c314d2a 100644 --- a/pkg/consumoor/route/libp2p/libp2p_prune.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_prune.gen.go @@ -80,7 +80,7 @@ func (b *libp2pPruneBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_publish_message.gen.go b/pkg/consumoor/route/libp2p/libp2p_publish_message.gen.go index 1053ea2be..647bc1a02 100644 --- a/pkg/consumoor/route/libp2p/libp2p_publish_message.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_publish_message.gen.go @@ -80,7 +80,7 @@ func (b *libp2pPublishMessageBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_recv_rpc.gen.go b/pkg/consumoor/route/libp2p/libp2p_recv_rpc.gen.go index d596aa15e..a3857940f 100644 --- a/pkg/consumoor/route/libp2p/libp2p_recv_rpc.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_recv_rpc.gen.go @@ -77,7 +77,7 @@ func (b *libp2pRecvRpcBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_reject_message.gen.go b/pkg/consumoor/route/libp2p/libp2p_reject_message.gen.go index 768670b7a..f82db222d 100644 --- a/pkg/consumoor/route/libp2p/libp2p_reject_message.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_reject_message.gen.go @@ -85,7 +85,7 @@ func (b *libp2pRejectMessageBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_remove_peer.gen.go b/pkg/consumoor/route/libp2p/libp2p_remove_peer.gen.go index 9bf586562..40d3885ec 100644 --- a/pkg/consumoor/route/libp2p/libp2p_remove_peer.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_remove_peer.gen.go @@ -76,7 +76,7 @@ func (b *libp2pRemovePeerBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe.gen.go b/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe.gen.go index c804c24b2..86df53205 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe.gen.go @@ -95,7 +95,7 @@ func (b *libp2pRpcDataColumnCustodyProbeBatch) appendMetadata(event *xatu.Decora b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe.go b/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe.go index 80474ac46..af4348ae9 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe.go @@ -210,7 +210,7 @@ func (b *libp2pRpcDataColumnCustodyProbeBatch) appendPayload( b.Error.Append(proto.Nullable[string]{}) } - // Compute peer_id_unique_key, preferring client metadata over payload. + // Compute peer_id_unique_key from metadata only (matching Vector behavior). peerID := "" if event.GetMeta() != nil && event.GetMeta().GetClient() != nil { @@ -221,10 +221,10 @@ func (b *libp2pRpcDataColumnCustodyProbeBatch) appendPayload( } } - if peerID == "" { - peerID = wrappedStringValue(payload.GetPeerId()) + if peerID != "" { + networkName := event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName() + b.PeerIDUniqueKey.Append(computePeerIDUniqueKey(peerID, networkName)) + } else { + b.PeerIDUniqueKey.Append(0) } - - networkName := event.GetMeta().GetClient().GetEthereum().GetNetwork().GetName() - b.PeerIDUniqueKey.Append(computePeerIDUniqueKey(peerID, networkName)) } diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe_test.go b/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe_test.go index 861f092a6..0458d1c1f 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe_test.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_data_column_custody_probe_test.go @@ -26,7 +26,11 @@ func TestSnapshot_libp2p_rpc_data_column_custody_probe(t *testing.T) { }, Meta: testfixture.MetaWithAdditional(&xatu.ClientMeta{ AdditionalData: &xatu.ClientMeta_Libp2PTraceRpcDataColumnCustodyProbe{ - Libp2PTraceRpcDataColumnCustodyProbe: &xatu.ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData{}, + Libp2PTraceRpcDataColumnCustodyProbe: &xatu.ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData{ + Metadata: &libp2ppb.TraceEventMetadata{ + PeerId: wrapperspb.String(testPeerID), + }, + }, }, }), Data: &xatu.DecoratedEvent_Libp2PTraceRpcDataColumnCustodyProbe{ diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_graft.gen.go b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_graft.gen.go index 5dae35664..b4553e627 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_graft.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_graft.gen.go @@ -83,7 +83,7 @@ func (b *libp2pRpcMetaControlGraftBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_idontwant.gen.go b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_idontwant.gen.go index 20ccf8226..fb691e453 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_idontwant.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_idontwant.gen.go @@ -81,7 +81,7 @@ func (b *libp2pRpcMetaControlIdontwantBatch) appendMetadata(event *xatu.Decorate b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_ihave.gen.go b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_ihave.gen.go index 15c1822d9..b7b4b31af 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_ihave.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_ihave.gen.go @@ -85,7 +85,7 @@ func (b *libp2pRpcMetaControlIhaveBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_iwant.gen.go b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_iwant.gen.go index 221dc5577..471458b77 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_iwant.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_iwant.gen.go @@ -81,7 +81,7 @@ func (b *libp2pRpcMetaControlIwantBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_prune.gen.go b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_prune.gen.go index 0fefd40c8..e17fc5e6f 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_prune.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_prune.gen.go @@ -86,7 +86,7 @@ func (b *libp2pRpcMetaControlPruneBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_prune.go b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_prune.go index 8e3274e19..47a4e5d1b 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_prune.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_control_prune.go @@ -102,12 +102,12 @@ func (b *libp2pRpcMetaControlPruneBatch) appendPayload( peerID := wrappedStringValue(payload.GetPeerId()) b.PeerIDUniqueKey.Append(computePeerIDUniqueKey(peerID, networkName)) - // Compute graft_peer_id_unique_key (nullable). + // Compute graft_peer_id_unique_key (nullable – NULL when no graft peer). graftPeerID := wrappedStringValue(payload.GetGraftPeerId()) if graftPeerID != "" { b.GraftPeerIDUniqueKey.Append(proto.NewNullable[int64](computePeerIDUniqueKey(graftPeerID, networkName))) } else { - b.GraftPeerIDUniqueKey.Append(proto.NewNullable[int64](route.SeaHashInt64(networkName))) + b.GraftPeerIDUniqueKey.Append(proto.Nullable[int64]{}) } // Parse topic fields. diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_message.gen.go b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_message.gen.go index 7481c4981..730b2d276 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_message.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_message.gen.go @@ -84,7 +84,7 @@ func (b *libp2pRpcMetaMessageBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_subscription.gen.go b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_subscription.gen.go index 46461d2d6..bf6530dc1 100644 --- a/pkg/consumoor/route/libp2p/libp2p_rpc_meta_subscription.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_rpc_meta_subscription.gen.go @@ -84,7 +84,7 @@ func (b *libp2pRpcMetaSubscriptionBatch) appendMetadata(event *xatu.DecoratedEve b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_send_rpc.gen.go b/pkg/consumoor/route/libp2p/libp2p_send_rpc.gen.go index 61f6222cc..e14e7c705 100644 --- a/pkg/consumoor/route/libp2p/libp2p_send_rpc.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_send_rpc.gen.go @@ -77,7 +77,7 @@ func (b *libp2pSendRpcBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/libp2p/libp2p_synthetic_heartbeat.gen.go b/pkg/consumoor/route/libp2p/libp2p_synthetic_heartbeat.gen.go index 7554da8c9..6d95c1997 100644 --- a/pkg/consumoor/route/libp2p/libp2p_synthetic_heartbeat.gen.go +++ b/pkg/consumoor/route/libp2p/libp2p_synthetic_heartbeat.gen.go @@ -106,7 +106,7 @@ func (b *libp2pSyntheticHeartbeatBatch) appendMetadata(event *xatu.DecoratedEven b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/mev/mev_relay_bid_trace.gen.go b/pkg/consumoor/route/mev/mev_relay_bid_trace.gen.go index f6c70b7c8..5cd712149 100644 --- a/pkg/consumoor/route/mev/mev_relay_bid_trace.gen.go +++ b/pkg/consumoor/route/mev/mev_relay_bid_trace.gen.go @@ -103,7 +103,7 @@ func (b *mevRelayBidTraceBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/mev/mev_relay_proposer_payload_delivered.gen.go b/pkg/consumoor/route/mev/mev_relay_proposer_payload_delivered.gen.go index faddc663d..f7a0e5603 100644 --- a/pkg/consumoor/route/mev/mev_relay_proposer_payload_delivered.gen.go +++ b/pkg/consumoor/route/mev/mev_relay_proposer_payload_delivered.gen.go @@ -96,7 +96,7 @@ func (b *mevRelayProposerPayloadDeliveredBatch) appendMetadata(event *xatu.Decor b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/mev/mev_relay_validator_registration.gen.go b/pkg/consumoor/route/mev/mev_relay_validator_registration.gen.go index e1723e4a7..48a9c928f 100644 --- a/pkg/consumoor/route/mev/mev_relay_validator_registration.gen.go +++ b/pkg/consumoor/route/mev/mev_relay_validator_registration.gen.go @@ -89,7 +89,7 @@ func (b *mevRelayValidatorRegistrationBatch) appendMetadata(event *xatu.Decorate b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/node/node_record_consensus.gen.go b/pkg/consumoor/route/node/node_record_consensus.gen.go index 565562ad9..b47b7b680 100644 --- a/pkg/consumoor/route/node/node_record_consensus.gen.go +++ b/pkg/consumoor/route/node/node_record_consensus.gen.go @@ -125,7 +125,7 @@ func (b *nodeRecordConsensusBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/node/node_record_execution.gen.go b/pkg/consumoor/route/node/node_record_execution.gen.go index d699c455e..eb3101fe2 100644 --- a/pkg/consumoor/route/node/node_record_execution.gen.go +++ b/pkg/consumoor/route/node/node_record_execution.gen.go @@ -113,7 +113,7 @@ func (b *nodeRecordExecutionBatch) appendMetadata(event *xatu.DecoratedEvent) { b.MetaClientVersion.Append(event.GetMeta().GetClient().GetVersion()) b.MetaClientImplementation.Append(event.GetMeta().GetClient().GetImplementation()) b.MetaClientOS.Append(event.GetMeta().GetClient().GetOs()) - b.MetaClientIP.Append(proto.NewNullable[proto.IPv6](route.NormalizeIPToIPv6(event.GetMeta().GetServer().GetClient().GetIP()))) + b.MetaClientIP.Append(route.NormalizeIPToIPv6Nullable(event.GetMeta().GetServer().GetClient().GetIP())) b.MetaClientGeoCity.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCity()) b.MetaClientGeoCountry.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountry()) b.MetaClientGeoCountryCode.Append(event.GetMeta().GetServer().GetClient().GetGeo().GetCountryCode()) diff --git a/pkg/consumoor/route/routes_test.go b/pkg/consumoor/route/routes_test.go index 0fa575533..3180e78c2 100644 --- a/pkg/consumoor/route/routes_test.go +++ b/pkg/consumoor/route/routes_test.go @@ -20,22 +20,8 @@ import ( ) func TestRegistryCoversAllKnownEvents(t *testing.T) { - // Explicitly document events consumoor intentionally does not flatten yet. - unsupported := map[xatu.Event_Name]string{ - xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE: "debug stream not modeled as table output", - xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE_V2: "debug stream not modeled as table output", - xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE_REORG: "debug stream not modeled as table output", - xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE_REORG_V2: "debug stream not modeled as table output", - xatu.Event_BEACON_API_ETH_V1_EVENTS_ATTESTATION: "deprecated in favor of V2 event", - xatu.Event_BEACON_API_ETH_V1_EVENTS_BLOCK: "deprecated in favor of V2 event", - xatu.Event_BEACON_API_ETH_V1_EVENTS_CHAIN_REORG: "deprecated in favor of V2 event", - xatu.Event_BEACON_API_ETH_V1_EVENTS_CONTRIBUTION_AND_PROOF: "deprecated in favor of V2 event", - xatu.Event_BEACON_API_ETH_V1_EVENTS_FINALIZED_CHECKPOINT: "deprecated in favor of V2 event", - xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD: "deprecated in favor of V2 event", - xatu.Event_BEACON_API_ETH_V1_EVENTS_VOLUNTARY_EXIT: "deprecated in favor of V2 event", - xatu.Event_BEACON_API_ETH_V2_BEACON_BLOCK: "deprecated in favor of V2 event", - xatu.Event_BEACON_P2P_ATTESTATION: "legacy event path not consumed by consumoor", - } + // Explicitly documented events consumoor intentionally does not flatten. + unsupported := route.UnsupportedEvents() covered := make(map[xatu.Event_Name]struct{}, 128) diff --git a/pkg/consumoor/route/unsupported_events.go b/pkg/consumoor/route/unsupported_events.go new file mode 100644 index 000000000..c1156b228 --- /dev/null +++ b/pkg/consumoor/route/unsupported_events.go @@ -0,0 +1,39 @@ +package route + +import "github.com/ethpandaops/xatu/pkg/proto/xatu" + +// intentionallyUnsupportedEvents documents event types consumoor deliberately +// does not flatten into ClickHouse tables. +var intentionallyUnsupportedEvents = map[xatu.Event_Name]string{ + xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE: "debug stream not modeled as table output", + xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE_V2: "debug stream not modeled as table output", + xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE_REORG: "debug stream not modeled as table output", + xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE_REORG_V2: "debug stream not modeled as table output", + xatu.Event_BEACON_API_ETH_V1_EVENTS_ATTESTATION: "deprecated in favor of V2 event", + xatu.Event_BEACON_API_ETH_V1_EVENTS_BLOCK: "deprecated in favor of V2 event", + xatu.Event_BEACON_API_ETH_V1_EVENTS_CHAIN_REORG: "deprecated in favor of V2 event", + xatu.Event_BEACON_API_ETH_V1_EVENTS_CONTRIBUTION_AND_PROOF: "deprecated in favor of V2 event", + xatu.Event_BEACON_API_ETH_V1_EVENTS_FINALIZED_CHECKPOINT: "deprecated in favor of V2 event", + xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD: "deprecated in favor of V2 event", + xatu.Event_BEACON_API_ETH_V1_EVENTS_VOLUNTARY_EXIT: "deprecated in favor of V2 event", + xatu.Event_BEACON_API_ETH_V2_BEACON_BLOCK: "deprecated in favor of V2 event", + xatu.Event_BEACON_P2P_ATTESTATION: "legacy event path not consumed by consumoor", +} + +// UnsupportedReason returns the documented reason when an event is +// intentionally unsupported by consumoor flatteners. +func UnsupportedReason(event xatu.Event_Name) (string, bool) { + reason, ok := intentionallyUnsupportedEvents[event] + + return reason, ok +} + +// UnsupportedEvents returns a copy of intentionally unsupported event reasons. +func UnsupportedEvents() map[xatu.Event_Name]string { + out := make(map[xatu.Event_Name]string, len(intentionallyUnsupportedEvents)) + for event, reason := range intentionallyUnsupportedEvents { + out[event] = reason + } + + return out +} diff --git a/pkg/consumoor/router/engine.go b/pkg/consumoor/router/engine.go index 3fc721cad..2b0b89474 100644 --- a/pkg/consumoor/router/engine.go +++ b/pkg/consumoor/router/engine.go @@ -1,12 +1,16 @@ package router import ( + "time" + "github.com/ethpandaops/xatu/pkg/consumoor/route" "github.com/ethpandaops/xatu/pkg/consumoor/telemetry" "github.com/ethpandaops/xatu/pkg/proto/xatu" "github.com/sirupsen/logrus" ) +const logSampleInterval = 30 * time.Second + // Result holds the routing decision for a single event: the target // table name and the route that will handle flattening. type Result struct { @@ -31,7 +35,8 @@ type Engine struct { // produces multiple. routesByEvent map[xatu.Event_Name][]route.Route - metrics *telemetry.Metrics + metrics *telemetry.Metrics + logSampler *telemetry.LogSampler } // New creates a routing engine with the given routes. @@ -45,6 +50,7 @@ func New( log: log.WithField("component", "router"), routesByEvent: make(map[xatu.Event_Name][]route.Route, len(routes)), metrics: metrics, + logSampler: telemetry.NewLogSampler(logSampleInterval), } disabled := make(map[xatu.Event_Name]struct{}, len(disabledEvents)) @@ -80,14 +86,46 @@ func (r *Engine) Route(event *xatu.DecoratedEvent) Outcome { eventName := event.GetEvent().GetName() - // Look up routes for this event. + // Look up routes for this event. Intentionally unsupported events + // are dropped (status delivered, no rows). Unknown/unexpected event + // types are NAK'd (StatusErrored) so Kafka does not advance offsets, + // preventing silent data loss when new event types appear before a + // matching route is deployed. routesForEvent, ok := r.routesByEvent[eventName] if !ok { + if reason, intentionallyUnsupported := route.UnsupportedReason(eventName); intentionallyUnsupported { + if r.metrics != nil { + r.metrics.MessagesDropped().WithLabelValues(eventName.String(), "no_flattener").Inc() + } + + if ok, suppressed := r.logSampler.Allow("drop:" + eventName.String()); ok { + entry := r.log. + WithField("event_name", eventName.String()). + WithField("reason", reason) + if suppressed > 0 { + entry = entry.WithField("suppressed", suppressed) + } + + entry.Debug("No route registered for intentionally unsupported event — dropping") + } + + return Outcome{Status: StatusDelivered} + } + if r.metrics != nil { - r.metrics.MessagesDropped().WithLabelValues(eventName.String(), "no_flattener").Inc() + r.metrics.MessagesDropped().WithLabelValues(eventName.String(), "no_route_nack").Inc() + } + + if ok, suppressed := r.logSampler.Allow(eventName.String()); ok { + entry := r.log.WithField("event_name", eventName.String()) + if suppressed > 0 { + entry = entry.WithField("suppressed", suppressed) + } + + entry.Warn("No route registered for event — messages will be NAK'd until a matching route is deployed") } - return Outcome{Status: StatusDelivered} + return Outcome{Status: StatusErrored} } results := make([]Result, 0, len(routesForEvent)) @@ -112,6 +150,13 @@ func (r *Engine) Route(event *xatu.DecoratedEvent) Outcome { for _, result := range results { r.metrics.MessagesRouted().WithLabelValues(eventName.String(), result.Table).Inc() } + + if ts := event.GetEvent().GetDateTime(); ts != nil { + lag := time.Since(ts.AsTime()).Seconds() + if lag >= 0 { + r.metrics.EventLag().WithLabelValues(eventName.String()).Observe(lag) + } + } } return Outcome{ diff --git a/pkg/consumoor/router/engine_test.go b/pkg/consumoor/router/engine_test.go index cf63678e1..c118f40ec 100644 --- a/pkg/consumoor/router/engine_test.go +++ b/pkg/consumoor/router/engine_test.go @@ -67,6 +67,48 @@ func TestNewRouterSkipsDisabledEvents(t *testing.T) { require.Equal(t, "table_b", disconnectedRoutes[0].TableName()) } +func TestRouteIntentionallyUnsupportedEventIsDropped(t *testing.T) { + routes := []route.Route{ + filterTestRoute{ + table: route.TableName("table_head"), + events: []xatu.Event_Name{xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD_V2}, + }, + } + + router := New(logrus.New(), routes, nil, newTestMetrics()) + + outcome := router.Route(&xatu.DecoratedEvent{ + Event: &xatu.Event{ + Id: "e1", + Name: xatu.Event_BEACON_API_ETH_V1_DEBUG_FORK_CHOICE_V2, + }, + }) + + require.Equal(t, StatusDelivered, outcome.Status) + require.Empty(t, outcome.Results) +} + +func TestRouteUnknownEventIsNAKed(t *testing.T) { + routes := []route.Route{ + filterTestRoute{ + table: route.TableName("table_head"), + events: []xatu.Event_Name{xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD_V2}, + }, + } + + router := New(logrus.New(), routes, nil, newTestMetrics()) + + outcome := router.Route(&xatu.DecoratedEvent{ + Event: &xatu.Event{ + Id: "e1", + Name: xatu.Event_Name(999_999), + }, + }) + + require.Equal(t, StatusErrored, outcome.Status) + require.Empty(t, outcome.Results) +} + func newTestMetrics() *telemetry.Metrics { ns := fmt.Sprintf("xatu_consumoor_router_test_%d", atomic.AddUint64(&testMetricNSCounter, 1)) diff --git a/pkg/consumoor/source/benthos.go b/pkg/consumoor/source/benthos.go index 55fde5496..bf31cf7a3 100644 --- a/pkg/consumoor/source/benthos.go +++ b/pkg/consumoor/source/benthos.go @@ -4,6 +4,7 @@ import ( "fmt" "os" "strings" + "time" _ "github.com/redpanda-data/benthos/v4/public/components/pure" "github.com/redpanda-data/benthos/v4/public/service" @@ -17,6 +18,16 @@ import ( const benthosOutputType = "xatu_clickhouse" +// GroupRetryConfig configures group-level retry behavior for partial table +// failures in processGroup. When a fanout flush partially fails (some tables +// succeed, others fail transiently), only the failed tables are retried with +// exponential backoff to limit write amplification. +type GroupRetryConfig struct { + MaxAttempts int + BaseDelay time.Duration + MaxDelay time.Duration +} + // NewBenthosStream creates a Benthos stream that consumes from Kafka and writes // to ClickHouse via the custom xatu_clickhouse output plugin. // When ownsWriter is true the output plugin manages the writer lifecycle @@ -30,6 +41,7 @@ func NewBenthosStream( routeEngine *router.Engine, writer Writer, ownsWriter bool, + groupRetry GroupRetryConfig, ) (*service.Stream, error) { if kafkaConfig == nil { return nil, fmt.Errorf("nil kafka config") @@ -48,19 +60,33 @@ func NewBenthosStream( } } + batchPolicy := service.BatchPolicy{} + if kafkaConfig.OutputBatchCount > 0 { + batchPolicy.Count = kafkaConfig.OutputBatchCount + } + + if kafkaConfig.OutputBatchPeriod > 0 { + batchPolicy.Period = kafkaConfig.OutputBatchPeriod.String() + } + if registerErr := env.RegisterBatchOutput( benthosOutputType, service.NewConfigSpec(), func(_ *service.ParsedConfig, _ *service.Resources) (out service.BatchOutput, policy service.BatchPolicy, maxInFlight int, err error) { return &xatuClickHouseOutput{ - log: log.WithField("component", "benthos_clickhouse_output"), - encoding: kafkaConfig.Encoding, - router: routeEngine, - writer: writer, - metrics: metrics, - rejectSink: rejectSink, - ownsWriter: ownsWriter, - }, service.BatchPolicy{}, 1, nil + log: log.WithField("component", "benthos_clickhouse_output"), + encoding: kafkaConfig.Encoding, + router: routeEngine, + writer: writer, + metrics: metrics, + rejectSink: rejectSink, + ownsWriter: ownsWriter, + outputBatchCount: kafkaConfig.OutputBatchCount, + logSampler: telemetry.NewLogSampler(30 * time.Second), + groupRetryMaxAttempts: groupRetry.MaxAttempts, + groupRetryBaseDelay: groupRetry.BaseDelay, + groupRetryMaxDelay: groupRetry.MaxDelay, + }, batchPolicy, kafkaConfig.MaxInFlight, nil }, ); registerErr != nil { closeRejectSink() @@ -106,14 +132,22 @@ func benthosConfigYAML(logLevel string, kafkaConfig *KafkaConfig) ([]byte, error "fetch_min_bytes": fmt.Sprintf("%dB", kafkaConfig.FetchMinBytes), "fetch_max_wait": fmt.Sprintf("%dms", kafkaConfig.FetchWaitMaxMs), "fetch_max_partition_bytes": fmt.Sprintf("%dB", kafkaConfig.MaxPartitionFetchBytes), + "fetch_max_bytes": fmt.Sprintf("%dB", kafkaConfig.FetchMaxBytes), "session_timeout": fmt.Sprintf("%dms", kafkaConfig.SessionTimeoutMs), "heartbeat_interval": fmt.Sprintf("%dms", kafkaConfig.heartbeatIntervalMs()), + "rebalance_timeout": kafkaConfig.RebalanceTimeout.String(), } if kafkaConfig.TopicRefreshInterval > 0 { inputKafka["metadata_max_age"] = kafkaConfig.TopicRefreshInterval.String() } + if kafkaConfig.ConnectTimeout > 0 { + inputKafka["tcp"] = map[string]any{ + "connect_timeout": kafkaConfig.ConnectTimeout.String(), + } + } + if kafkaConfig.TLS.Enabled { tlsObj := map[string]any{ "enabled": true, @@ -197,7 +231,7 @@ func benthosSASLObject(cfg *SASLConfig) (map[string]any, error) { return nil, err } - mechanism := strings.TrimSpace(cfg.Mechanism) + mechanism := strings.ToUpper(strings.TrimSpace(cfg.Mechanism)) if mechanism == "" { mechanism = SASLMechanismPLAIN } diff --git a/pkg/consumoor/source/benthos_test.go b/pkg/consumoor/source/benthos_test.go index b3a208e28..6328759f2 100644 --- a/pkg/consumoor/source/benthos_test.go +++ b/pkg/consumoor/source/benthos_test.go @@ -23,6 +23,7 @@ import ( ch "github.com/ClickHouse/ch-go" "github.com/ClickHouse/ch-go/proto" + "github.com/ethpandaops/xatu/pkg/consumoor/clickhouse" "github.com/ethpandaops/xatu/pkg/consumoor/route" "github.com/ethpandaops/xatu/pkg/consumoor/router" "github.com/ethpandaops/xatu/pkg/consumoor/telemetry" @@ -66,35 +67,40 @@ func (w *testWriter) Stop(context.Context) error { return nil } -func (w *testWriter) Write(table string, _ *xatu.DecoratedEvent) { +func (w *testWriter) FlushTableEvents(_ context.Context, tableEvents map[string][]*xatu.DecoratedEvent) *clickhouse.FlushResult { + w.flushCalls++ + if w.writes == nil { - w.writes = make(map[string]int) + w.writes = make(map[string]int, len(tableEvents)) } - w.writes[table]++ -} - -func (w *testWriter) FlushTables(_ context.Context, tables []string) error { - w.flushCalls++ - - tableSet := make(map[string]struct{}, len(tables)) - for _, t := range tables { - tableSet[t] = struct{}{} + for table, events := range tableEvents { + w.writes[table] += len(events) } for i, err := range w.flushErrs { if twe, ok := err.(*testWriteError); ok { - if _, found := tableSet[twe.table]; !found { + if _, found := tableEvents[twe.table]; !found { continue } } w.flushErrs = append(w.flushErrs[:i], w.flushErrs[i+1:]...) - return err + result := &clickhouse.FlushResult{ + TableErrors: make(map[string]error, 1), + } + // Attribute the error to the first table in the map for test purposes. + for table := range tableEvents { + result.TableErrors[table] = err + + break + } + + return result } - return nil + return &clickhouse.FlushResult{} } func (w *testWriter) Ping(context.Context) error { @@ -145,9 +151,12 @@ func TestBenthosConfigYAML(t *testing.T) { FetchMinBytes: 64, FetchWaitMaxMs: 250, MaxPartitionFetchBytes: 1048576, + FetchMaxBytes: 5242880, SessionTimeoutMs: 30000, + RebalanceTimeout: 15 * time.Second, OffsetDefault: "latest", CommitInterval: 7 * time.Second, + ConnectTimeout: 10 * time.Second, } raw, err := benthosConfigYAML("debug", cfg) @@ -165,6 +174,12 @@ func TestBenthosConfigYAML(t *testing.T) { assert.Equal(t, "xatu-consumoor", kafka["consumer_group"]) assert.Equal(t, "latest", kafka["start_offset"]) assert.Equal(t, "7s", kafka["commit_period"]) + assert.Equal(t, "5242880B", kafka["fetch_max_bytes"]) + assert.Equal(t, "1048576B", kafka["fetch_max_partition_bytes"]) + + tcp, ok := kafka["tcp"].(map[string]any) + require.True(t, ok, "tcp block should be present when ConnectTimeout > 0") + assert.Equal(t, "10s", tcp["connect_timeout"]) output, ok := parsed["output"].(map[string]any) require.True(t, ok) @@ -173,6 +188,39 @@ func TestBenthosConfigYAML(t *testing.T) { assert.True(t, hasOutput) } +func TestBenthosConfigYAML_NoTCPBlockWhenConnectTimeoutZero(t *testing.T) { + cfg := &KafkaConfig{ + Brokers: []string{"kafka-1:9092"}, + Topics: []string{"^test-.+"}, + ConsumerGroup: "xatu-consumoor", + Encoding: "json", + FetchMinBytes: 1, + FetchWaitMaxMs: 250, + MaxPartitionFetchBytes: 1048576, + FetchMaxBytes: 10485760, + SessionTimeoutMs: 30000, + RebalanceTimeout: 15 * time.Second, + OffsetDefault: "earliest", + CommitInterval: 5 * time.Second, + ConnectTimeout: 0, + } + + raw, err := benthosConfigYAML("info", cfg) + require.NoError(t, err) + + var parsed map[string]any + require.NoError(t, yaml.Unmarshal(raw, &parsed)) + + input, ok := parsed["input"].(map[string]any) + require.True(t, ok) + + kafka, ok := input["kafka_franz"].(map[string]any) + require.True(t, ok) + + _, hasTCP := kafka["tcp"] + assert.False(t, hasTCP, "tcp block should be absent when ConnectTimeout is 0") +} + func TestBenthosSASLObjectUsesPasswordFile(t *testing.T) { dir := t.TempDir() secretPath := filepath.Join(dir, "secret.txt") @@ -221,6 +269,7 @@ func TestWriteBatchBatchModeRejectsMalformedWithoutRetry(t *testing.T) { }), writer: writer, metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), rejectSink: rejectSink, } @@ -259,6 +308,7 @@ func TestWriteBatchBatchModeTransientWriteFailureFailsImpactedMessages(t *testin }), writer: writer, metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), rejectSink: &testRejectSink{}, } @@ -274,11 +324,12 @@ func TestWriteBatchBatchModeTransientWriteFailureFailsImpactedMessages(t *testin func TestWriteBatchRejectSinkFailureMakesMessageRetry(t *testing.T) { output := &xatuClickHouseOutput{ - log: logrus.New(), - encoding: "json", - router: newRouter(t, nil), - writer: &testWriter{}, - metrics: newTestMetrics(), + log: logrus.New(), + encoding: "json", + router: newRouter(t, nil), + writer: &testWriter{}, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), rejectSink: &testRejectSink{ err: errors.New("dlq unavailable"), }, @@ -381,6 +432,7 @@ func TestWriteBatchMultiTableTransientFailureFailsAllImpactedMessages(t *testing }), writer: writer, metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), rejectSink: &testRejectSink{}, } @@ -406,7 +458,7 @@ func TestWriteBatchMultiTablePermanentFailureRejectsAllImpactedMessages(t *testi // permanent error, all messages in the group should be DLQ'd. writer := &testWriter{ flushErrs: []error{ - &ch.Exception{Code: proto.ErrUnknownTable, Name: "DB::Exception", Message: "test permanent error"}, + &ch.Exception{Code: proto.ErrCannotParseNumber, Name: "DB::Exception", Message: "test permanent error"}, }, } @@ -426,6 +478,7 @@ func TestWriteBatchMultiTablePermanentFailureRejectsAllImpactedMessages(t *testi }), writer: writer, metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), rejectSink: rejectSink, } @@ -470,6 +523,7 @@ func TestWriteBatchCtxCancelledReturnsCtxErr(t *testing.T) { }), writer: writer, metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), rejectSink: &testRejectSink{}, } @@ -500,6 +554,7 @@ func TestWriteBatchUnknownFlushFailureFailsGroupMessages(t *testing.T) { }), writer: writer, metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), rejectSink: &testRejectSink{}, } @@ -526,6 +581,825 @@ func TestKafkaTopicMetadataFallback(t *testing.T) { assert.Equal(t, "xatu-mainnet", kafkaTopicMetadata(msg)) } +func TestKafkaConfig_Validate_OutputBatch(t *testing.T) { + validKafka := func() *KafkaConfig { + return &KafkaConfig{ + Brokers: []string{"kafka-1:9092"}, + Topics: []string{"^test-.+"}, + ConsumerGroup: "xatu-consumoor", + Encoding: "json", + FetchMinBytes: 1, + FetchWaitMaxMs: 250, + MaxPartitionFetchBytes: 1048576, + FetchMaxBytes: 10485760, + SessionTimeoutMs: 30000, + RebalanceTimeout: 15 * time.Second, + OffsetDefault: "earliest", + CommitInterval: 5 * time.Second, + ShutdownTimeout: 30 * time.Second, + OutputBatchCount: 1000, + OutputBatchPeriod: 1 * time.Second, + MaxInFlight: 64, + } + } + + tests := []struct { + name string + mutate func(*KafkaConfig) + wantErr string + }{ + { + name: "defaults valid", + mutate: func(_ *KafkaConfig) {}, + }, + { + name: "zero count valid (opt-out)", + mutate: func(c *KafkaConfig) { c.OutputBatchCount = 0 }, + }, + { + name: "zero period valid (opt-out)", + mutate: func(c *KafkaConfig) { c.OutputBatchPeriod = 0 }, + }, + { + name: "negative count", + mutate: func(c *KafkaConfig) { c.OutputBatchCount = -1 }, + wantErr: "outputBatchCount must be >= 0", + }, + { + name: "negative period", + mutate: func(c *KafkaConfig) { c.OutputBatchPeriod = -1 * time.Second }, + wantErr: "outputBatchPeriod must be >= 0", + }, + { + name: "maxInFlight 1 valid", + mutate: func(c *KafkaConfig) { c.MaxInFlight = 1 }, + }, + { + name: "maxInFlight 0 rejected", + mutate: func(c *KafkaConfig) { c.MaxInFlight = 0 }, + wantErr: "maxInFlight must be >= 1", + }, + { + name: "maxInFlight negative rejected", + mutate: func(c *KafkaConfig) { c.MaxInFlight = -1 }, + wantErr: "maxInFlight must be >= 1", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := validKafka() + tt.mutate(cfg) + + err := cfg.Validate() + if tt.wantErr != "" { + require.Error(t, err) + assert.Contains(t, err.Error(), tt.wantErr) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestKafkaConfig_Validate_TopicOverrides(t *testing.T) { + validKafka := func() *KafkaConfig { + return &KafkaConfig{ + Brokers: []string{"kafka-1:9092"}, + Topics: []string{"^test-.+"}, + ConsumerGroup: "xatu-consumoor", + Encoding: "json", + FetchMinBytes: 1, + FetchWaitMaxMs: 250, + MaxPartitionFetchBytes: 1048576, + FetchMaxBytes: 10485760, + SessionTimeoutMs: 30000, + RebalanceTimeout: 15 * time.Second, + OffsetDefault: "earliest", + CommitInterval: 5 * time.Second, + ShutdownTimeout: 30 * time.Second, + OutputBatchCount: 1000, + OutputBatchPeriod: 1 * time.Second, + MaxInFlight: 64, + } + } + + tests := []struct { + name string + mutate func(*KafkaConfig) + wantErr string + }{ + { + name: "valid override passes", + mutate: func(c *KafkaConfig) { + c.TopicOverrides = map[string]TopicOverride{ + "test-blocks": { + OutputBatchCount: intPtr(100), + OutputBatchPeriod: durPtr(100 * time.Millisecond), + MaxInFlight: intPtr(4), + }, + } + }, + }, + { + name: "negative outputBatchCount in override rejected", + mutate: func(c *KafkaConfig) { + c.TopicOverrides = map[string]TopicOverride{ + "test-blocks": {OutputBatchCount: intPtr(-1)}, + } + }, + wantErr: "kafka.topicOverrides.test-blocks: outputBatchCount must be >= 0", + }, + { + name: "negative outputBatchPeriod in override rejected", + mutate: func(c *KafkaConfig) { + c.TopicOverrides = map[string]TopicOverride{ + "test-blocks": {OutputBatchPeriod: durPtr(-1 * time.Second)}, + } + }, + wantErr: "kafka.topicOverrides.test-blocks: outputBatchPeriod must be >= 0", + }, + { + name: "zero maxInFlight in override rejected", + mutate: func(c *KafkaConfig) { + c.TopicOverrides = map[string]TopicOverride{ + "test-blocks": {MaxInFlight: intPtr(0)}, + } + }, + wantErr: "kafka.topicOverrides.test-blocks: maxInFlight must be >= 1", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := validKafka() + tt.mutate(cfg) + + err := cfg.Validate() + if tt.wantErr != "" { + require.Error(t, err) + assert.Contains(t, err.Error(), tt.wantErr) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestBenthosOutputBatchPolicy(t *testing.T) { + tests := []struct { + name string + count int + period time.Duration + wantCount int + wantPeriod string + }{ + { + name: "defaults", + count: 1000, + period: 1 * time.Second, + wantCount: 1000, + wantPeriod: "1s", + }, + { + name: "zero count disables count batching", + count: 0, + period: 1 * time.Second, + wantCount: 0, + wantPeriod: "1s", + }, + { + name: "zero period disables period flushing", + count: 500, + period: 0, + wantCount: 500, + wantPeriod: "", + }, + { + name: "both zero preserves opt-out", + count: 0, + period: 0, + wantCount: 0, + wantPeriod: "", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Mirror the batch policy construction from NewBenthosStream. + policy := service.BatchPolicy{} + if tt.count > 0 { + policy.Count = tt.count + } + + if tt.period > 0 { + policy.Period = tt.period.String() + } + + assert.Equal(t, tt.wantCount, policy.Count) + assert.Equal(t, tt.wantPeriod, policy.Period) + }) + } +} + +// mustNilEventJSON returns a valid JSON-encoded DecoratedEvent with a nil +// Event field. The router treats this as StatusRejected. +func mustNilEventJSON(t *testing.T) []byte { + t.Helper() + + raw, err := protojson.Marshal(&xatu.DecoratedEvent{}) + require.NoError(t, err) + + return raw +} + +// succeededIndexes returns the message indexes that are NOT marked as failed +// in the BatchError. When err is nil, all indexes are returned. +func succeededIndexes(msgs service.MessageBatch, err error) []int { + failed := make(map[int]struct{}, len(msgs)) + + var batchErr *service.BatchError + if errors.As(err, &batchErr) { + //nolint:staticcheck // Tests intentionally use direct indexes from this batch. + batchErr.WalkMessages(func(idx int, _ *service.Message, msgErr error) bool { + if msgErr != nil { + failed[idx] = struct{}{} + } + + return true + }) + } + + out := make([]int, 0, len(msgs)) + + for i := range msgs { + if _, isFailed := failed[i]; !isFailed { + out = append(out, i) + } + } + + return out +} + +// --------------------------------------------------------------------------- +// At-Least-Once Delivery Guarantee Tests +// --------------------------------------------------------------------------- +// +// These tests verify the fundamental at-least-once delivery invariant: +// +// A Kafka offset is committed (message ACK'd) if and only if the message +// has been durably handled: successfully written to ClickHouse, sent to the +// DLQ, or intentionally dropped by the routing layer. +// +// Any other outcome (transient failures, DLQ write errors, context +// cancellation) must cause WriteBatch to return an error, preventing +// Benthos from committing the offset so Kafka redelivers the message. +// +// Tests are organized into three categories: +// +// ack/ — WriteBatch returns nil; all messages are safe to commit. +// nak/ — WriteBatch returns an error; impacted messages must be redelivered. +// mixed/ — Some messages ACK, others NAK within the same batch. + +func TestWriteBatchAtLeastOnceDelivery(t *testing.T) { + headRoute := testRoute{ + eventName: xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD, + table: "beacon_head", + } + blockRoute := testRoute{ + eventName: xatu.Event_BEACON_API_ETH_V1_EVENTS_BLOCK, + table: "beacon_block", + } + + // ----------------------------------------------------------------- + // ACK cases: WriteBatch returns nil — all messages offset-committed. + // ----------------------------------------------------------------- + t.Run("ack", func(t *testing.T) { + t.Run("successful_flush_commits_all_offsets", func(t *testing.T) { + writer := &testWriter{} + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: writer, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{}, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 1), + newKafkaMessage(mustEventJSON(t, "e2", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 2), + newKafkaMessage(mustEventJSON(t, "e3", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 3), + } + + err := output.WriteBatch(context.Background(), msgs) + require.NoError(t, err, "successful flush must ACK all messages") + assert.Equal(t, 1, writer.flushCalls) + assert.Equal(t, 3, writer.writes["beacon_head"]) + }) + + t.Run("decode_error_with_working_dlq_commits_offset", func(t *testing.T) { + rejectSink := &testRejectSink{} + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{}, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: rejectSink, + } + + msgs := service.MessageBatch{ + newKafkaMessage([]byte("not-valid-json{"), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.NoError(t, err, + "decode error with working DLQ must ACK (message is durably in DLQ)") + require.Len(t, rejectSink.records, 1) + assert.Equal(t, rejectReasonDecode, rejectSink.records[0].Reason) + }) + + t.Run("permanent_write_error_with_working_dlq_commits_offset", func(t *testing.T) { + rejectSink := &testRejectSink{} + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{ + flushErrs: []error{ + &ch.Exception{ + Code: proto.ErrCannotParseNumber, + Name: "DB::Exception", + Message: "bad number", + }, + }, + }, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: rejectSink, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.NoError(t, err, + "permanent write error with working DLQ must ACK (message is in DLQ)") + require.Len(t, rejectSink.records, 1) + assert.Equal(t, rejectReasonWritePermanent, rejectSink.records[0].Reason) + }) + + t.Run("intentionally_unsupported_event_type_silently_commits", func(t *testing.T) { + // BLOCK is intentionally unsupported and should be dropped + // (ACK'd) without any ClickHouse writes. + writer := &testWriter{} + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: writer, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{}, + } + + msgs := service.MessageBatch{ + // BLOCK event has no registered route (only HEAD is registered). + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_BLOCK), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.NoError(t, err, + "intentionally unsupported event types should be dropped and ACK'd") + assert.Equal(t, 0, writer.flushCalls, + "no flush should occur for unsupported events") + }) + + t.Run("unknown_event_type_returns_batch_error", func(t *testing.T) { + // Unknown event enum values are not intentionally unsupported; + // they should NAK so offsets do not advance silently. + writer := &testWriter{} + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: writer, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{}, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_Name(999_999)), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err, + "unknown event types must NAK to avoid silent data loss") + assert.Equal(t, 0, writer.flushCalls, + "no flush should occur for unknown events") + }) + + t.Run("nil_event_rejected_with_working_dlq_commits", func(t *testing.T) { + // A valid proto with nil Event field triggers StatusRejected + // in the router. With a working DLQ, the message is sent + // there and ACK'd. + rejectSink := &testRejectSink{} + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{}, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: rejectSink, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustNilEventJSON(t), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.NoError(t, err, + "route-rejected with working DLQ must ACK") + require.Len(t, rejectSink.records, 1) + assert.Equal(t, rejectReasonRouteRejected, rejectSink.records[0].Reason) + }) + + t.Run("nil_event_rejected_without_dlq_still_commits", func(t *testing.T) { + // Route rejections are intentional — the event type is not + // configured. Even without a DLQ the message is ACK'd to + // avoid infinite redelivery of permanently unroutable events. + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{}, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: nil, // no DLQ + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustNilEventJSON(t), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.NoError(t, err, + "route-rejected without DLQ must still ACK (intentional drop)") + }) + + t.Run("empty_batch_returns_nil", func(t *testing.T) { + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, nil), + writer: &testWriter{}, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{}, + } + + err := output.WriteBatch(context.Background(), service.MessageBatch{}) + require.NoError(t, err) + }) + }) + + // ----------------------------------------------------------------- + // NAK cases: WriteBatch returns error — messages must be redelivered. + // ----------------------------------------------------------------- + t.Run("nak", func(t *testing.T) { + t.Run("transient_flush_error_naks_impacted_messages", func(t *testing.T) { + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{ + flushErrs: []error{ + &testWriteError{table: "beacon_head", permanent: false}, + }, + }, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{}, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 1), + newKafkaMessage(mustEventJSON(t, "e2", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 2), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err) + assert.Equal(t, []int{0, 1}, failedIndexesFromBatchError(t, msgs, err), + "transient flush failure must NAK all messages in the group") + }) + + t.Run("unknown_flush_error_naks_all_messages", func(t *testing.T) { + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{ + flushErrs: []error{errors.New("unexpected infrastructure error")}, + }, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{}, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err) + assert.Equal(t, []int{0}, failedIndexesFromBatchError(t, msgs, err), + "unclassified flush error must NAK — cannot assume data was written") + }) + + t.Run("context_cancelled_before_processing_naks_batch", func(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + cancel() + + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{}, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{}, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 1), + } + + err := output.WriteBatch(ctx, msgs) + require.Error(t, err) + assert.ErrorIs(t, err, context.Canceled, + "cancelled context must NAK the entire batch") + }) + + t.Run("decode_error_without_dlq_naks_for_redelivery", func(t *testing.T) { + // When no DLQ is configured (nil rejectSink), decode errors + // must NAK to avoid silent data loss. The message will be + // redelivered by Kafka indefinitely. + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{}, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: nil, + } + + msgs := service.MessageBatch{ + newKafkaMessage([]byte("corrupt"), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err) + assert.Equal(t, []int{0}, failedIndexesFromBatchError(t, msgs, err), + "decode error without DLQ must NAK to prevent silent data loss") + }) + + t.Run("permanent_write_error_without_dlq_naks_for_redelivery", func(t *testing.T) { + // Without a DLQ, even permanent write errors must NAK. The + // message will be redelivered, which will fail again — but + // this is preferable to silent data loss. + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{ + flushErrs: []error{ + &ch.Exception{ + Code: proto.ErrUnknownTable, + Name: "DB::Exception", + Message: "table gone", + }, + }, + }, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: nil, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err) + assert.Equal(t, []int{0}, failedIndexesFromBatchError(t, msgs, err), + "permanent write error without DLQ must NAK") + }) + + t.Run("decode_error_with_broken_dlq_naks", func(t *testing.T) { + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{}, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{ + err: errors.New("kafka produce timeout"), + }, + } + + msgs := service.MessageBatch{ + newKafkaMessage([]byte("{{{"), "t", 0, 1), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err) + assert.Equal(t, []int{0}, failedIndexesFromBatchError(t, msgs, err), + "DLQ write failure must NAK — message is not durably handled") + }) + + t.Run("permanent_write_error_with_broken_dlq_naks", func(t *testing.T) { + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{ + flushErrs: []error{ + &ch.Exception{ + Code: proto.ErrUnknownTable, + Name: "DB::Exception", + Message: "table gone", + }, + }, + }, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{ + err: errors.New("kafka produce timeout"), + }, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 1), + newKafkaMessage(mustEventJSON(t, "e2", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 2), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err) + assert.Equal(t, []int{0, 1}, failedIndexesFromBatchError(t, msgs, err), + "permanent error + DLQ failure must NAK all impacted messages") + }) + }) + + // ----------------------------------------------------------------- + // Mixed cases: some messages ACK, others NAK in the same batch. + // ----------------------------------------------------------------- + t.Run("mixed", func(t *testing.T) { + t.Run("valid_and_malformed_with_working_dlq_all_ack", func(t *testing.T) { + // Malformed message goes to DLQ (ACK), valid message is + // flushed to ClickHouse (ACK). Everything commits. + writer := &testWriter{} + rejectSink := &testRejectSink{} + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: writer, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: rejectSink, + } + + msgs := service.MessageBatch{ + newKafkaMessage([]byte("{bad"), "t", 0, 1), + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 2), + } + + err := output.WriteBatch(context.Background(), msgs) + require.NoError(t, err, + "malformed→DLQ + valid→CH: both are durably handled, all ACK") + assert.Equal(t, 1, writer.flushCalls) + assert.Equal(t, 1, writer.writes["beacon_head"]) + require.Len(t, rejectSink.records, 1) + assert.Equal(t, rejectReasonDecode, rejectSink.records[0].Reason) + }) + + t.Run("two_event_groups_one_transient_fail_only_that_group_naks", func(t *testing.T) { + // Two event types in the same batch. One group flushes + // successfully, the other hits a transient error. Only the + // failed group's messages should be NAK'd. + writer := &testWriter{ + flushErrs: []error{ + &testWriteError{table: "beacon_block", permanent: false}, + }, + } + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute, blockRoute}), + writer: writer, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{}, + } + + msgs := service.MessageBatch{ + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 1), + newKafkaMessage(mustEventJSON(t, "e2", xatu.Event_BEACON_API_ETH_V1_EVENTS_BLOCK), "t", 0, 2), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err, "batch should fail because one group had a transient error") + + failed := failedIndexesFromBatchError(t, msgs, err) + succeeded := succeededIndexes(msgs, err) + + // HEAD (index 0) should succeed, BLOCK (index 1) should fail. + assert.Equal(t, []int{1}, failed, + "only the BLOCK group (transient failure) should be NAK'd") + assert.Equal(t, []int{0}, succeeded, + "the HEAD group (successful flush) should be ACK'd") + }) + + t.Run("malformed_with_broken_dlq_naks_valid_messages_still_ack", func(t *testing.T) { + // Decode error + DLQ failure → NAK that message. + // Valid message → successful flush → ACK. + writer := &testWriter{} + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: writer, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{ + err: errors.New("dlq unavailable"), + }, + } + + msgs := service.MessageBatch{ + newKafkaMessage([]byte("{bad"), "t", 0, 1), + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 2), + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err) + + failed := failedIndexesFromBatchError(t, msgs, err) + succeeded := succeededIndexes(msgs, err) + + assert.Equal(t, []int{0}, failed, + "malformed message with DLQ failure must NAK") + assert.Equal(t, []int{1}, succeeded, + "valid message with successful flush must ACK") + }) + + t.Run("decode_dlq_failure_plus_flush_failure_naks_both", func(t *testing.T) { + // Edge case: Phase 1 produces a NAK (decode error + DLQ + // failure), AND Phase 2 produces a NAK (transient flush). + // Both messages should be NAK'd. + // + // NOTE: WriteBatch currently overwrites the Phase 1 + // BatchError when Phase 2 fails, losing the decode + // failure's NAK. This test documents the expected correct + // behavior — if it fails, it reveals a bug where Phase 1 + // failures are silently dropped. + output := &xatuClickHouseOutput{ + log: logrus.New(), + encoding: "json", + router: newRouter(t, []route.Route{headRoute}), + writer: &testWriter{ + flushErrs: []error{ + &testWriteError{table: "beacon_head", permanent: false}, + }, + }, + metrics: newTestMetrics(), + logSampler: telemetry.NewLogSampler(time.Minute), + rejectSink: &testRejectSink{ + err: errors.New("dlq unavailable"), + }, + } + + msgs := service.MessageBatch{ + newKafkaMessage([]byte("{bad"), "t", 0, 1), // decode error → DLQ fails + newKafkaMessage(mustEventJSON(t, "e1", xatu.Event_BEACON_API_ETH_V1_EVENTS_HEAD), "t", 0, 2), // flush fails + } + + err := output.WriteBatch(context.Background(), msgs) + require.Error(t, err) + assert.Equal(t, []int{0, 1}, failedIndexesFromBatchError(t, msgs, err), + "both the decode-DLQ-failed message and flush-failed message must NAK") + }) + }) +} + func TestFranzSASLMechanism(t *testing.T) { t.Run("defaults to PLAIN", func(t *testing.T) { mech, err := franzSASLMechanism(&SASLConfig{ diff --git a/pkg/consumoor/source/config.go b/pkg/consumoor/source/config.go index f2f9ff855..5fc4d0522 100644 --- a/pkg/consumoor/source/config.go +++ b/pkg/consumoor/source/config.go @@ -26,6 +26,31 @@ var supportedSASLMechanisms = map[string]struct{}{ SASLMechanismOAUTHBEARER: {}, } +// TopicOverride holds per-topic batch settings that override KafkaConfig defaults. +// Nil pointer fields inherit the global default. +type TopicOverride struct { + OutputBatchCount *int `yaml:"outputBatchCount"` + OutputBatchPeriod *time.Duration `yaml:"outputBatchPeriod"` + MaxInFlight *int `yaml:"maxInFlight"` +} + +// Validate checks the per-topic override for errors. +func (o *TopicOverride) Validate(topic string) error { + if o.OutputBatchCount != nil && *o.OutputBatchCount < 0 { + return fmt.Errorf("kafka.topicOverrides.%s: outputBatchCount must be >= 0", topic) + } + + if o.OutputBatchPeriod != nil && *o.OutputBatchPeriod < 0 { + return fmt.Errorf("kafka.topicOverrides.%s: outputBatchPeriod must be >= 0", topic) + } + + if o.MaxInFlight != nil && *o.MaxInFlight < 1 { + return fmt.Errorf("kafka.topicOverrides.%s: maxInFlight must be >= 1", topic) + } + + return nil +} + // KafkaConfig configures the Kafka consumer. type KafkaConfig struct { // Brokers is a list of Kafka broker addresses. @@ -47,10 +72,19 @@ type KafkaConfig struct { // FetchWaitMaxMs is the maximum time to wait for fetch responses. FetchWaitMaxMs int `yaml:"fetchWaitMaxMs" default:"250"` // MaxPartitionFetchBytes is the max bytes per partition per request. - MaxPartitionFetchBytes int32 `yaml:"maxPartitionFetchBytes" default:"10485760"` + MaxPartitionFetchBytes int32 `yaml:"maxPartitionFetchBytes" default:"3145728"` + // FetchMaxBytes is the max total bytes per fetch request across all + // partitions from a single broker. With many independent consumers + // (one per topic) this is the primary lever for capping in-flight + // memory from Kafka fetch buffers. Default: 10 MiB. + FetchMaxBytes int32 `yaml:"fetchMaxBytes" default:"10485760"` // SessionTimeoutMs is the consumer group session timeout. SessionTimeoutMs int `yaml:"sessionTimeoutMs" default:"30000"` + // RebalanceTimeout is the maximum time group members are allowed to + // take when a rebalance has begun (finish work, commit offsets, rejoin). + // Lower values speed up partition reassignment when scaling. Default: 15s. + RebalanceTimeout time.Duration `yaml:"rebalanceTimeout" default:"15s"` // OffsetDefault controls where to start consuming when no offset exists. // Valid values: "earliest" or "latest". @@ -72,6 +106,32 @@ type KafkaConfig struct { // LagPollInterval controls how often consumer lag is polled from Kafka. // Set to 0 to disable lag monitoring. Default: 30s. LagPollInterval time.Duration `yaml:"lagPollInterval" default:"30s"` + // ConnectTimeout is the maximum time a TCP dial to a broker will wait + // for a connection to complete. A reasonable value (e.g. 10s) prevents + // hung dials from generating noisy warnings when some brokers are + // temporarily unreachable. Default: 10s. Set to 0 to disable. + ConnectTimeout time.Duration `yaml:"connectTimeout" default:"10s"` + + // OutputBatchCount is the number of messages Benthos accumulates before + // calling WriteBatch on the output plugin. Higher values increase INSERT + // throughput by writing more rows per ClickHouse INSERT. Set to 0 to + // disable count-based batching. Default: 10000. + OutputBatchCount int `yaml:"outputBatchCount" default:"10000"` + // OutputBatchPeriod is the maximum time Benthos waits to fill a batch + // before flushing a partial batch. Ensures low-volume topics still make + // progress. Default: 5s. Set to 0 to disable period-based flushing. + OutputBatchPeriod time.Duration `yaml:"outputBatchPeriod" default:"5s"` + + // MaxInFlight is the maximum number of concurrent WriteBatch calls + // Benthos makes for each stream's output. Higher values increase + // throughput by allowing concurrent ClickHouse INSERTs and bigger + // natural batches. Default: 64. + MaxInFlight int `yaml:"maxInFlight" default:"64"` + + // TopicOverrides contains per-topic batch settings keyed by exact topic name. + // Overrides are matched against discovered concrete topic names. Unset fields + // inherit the global defaults from this KafkaConfig. + TopicOverrides map[string]TopicOverride `yaml:"topicOverrides"` } // SASLConfig configures SASL authentication for Kafka. @@ -112,6 +172,10 @@ func (c *KafkaConfig) Validate() error { return errors.New("kafka: sessionTimeoutMs must be > 0") } + if c.RebalanceTimeout < 100*time.Millisecond { + return errors.New("kafka: rebalanceTimeout must be >= 100ms") + } + if c.CommitInterval <= 0 { return errors.New("kafka: commitInterval must be positive") } @@ -126,6 +190,48 @@ func (c *KafkaConfig) Validate() error { ) } + if c.OutputBatchCount < 0 { + return errors.New("kafka: outputBatchCount must be >= 0") + } + + if c.OutputBatchPeriod < 0 { + return errors.New("kafka: outputBatchPeriod must be >= 0") + } + + if c.MaxInFlight < 1 { + return errors.New("kafka: maxInFlight must be >= 1") + } + + if c.FetchMinBytes < 1 { + return errors.New("kafka: fetchMinBytes must be >= 1") + } + + if c.FetchWaitMaxMs <= 0 { + return errors.New("kafka: fetchWaitMaxMs must be > 0") + } + + if c.MaxPartitionFetchBytes < 1 { + return errors.New("kafka: maxPartitionFetchBytes must be >= 1") + } + + if c.FetchMaxBytes < 1 { + return errors.New("kafka: fetchMaxBytes must be >= 1") + } + + if c.LagPollInterval < 0 { + return errors.New("kafka: lagPollInterval must be >= 0") + } + + if c.ConnectTimeout < 0 { + return errors.New("kafka: connectTimeout must be >= 0") + } + + for topic, override := range c.TopicOverrides { + if err := override.Validate(topic); err != nil { + return err + } + } + if err := c.TLS.Validate(); err != nil { return fmt.Errorf("kafka.%w", err) } @@ -139,6 +245,31 @@ func (c *KafkaConfig) Validate() error { return nil } +// ApplyTopicOverride returns a shallow copy with per-topic overrides merged in. +// Fields not set in the override keep the global default. +func (c *KafkaConfig) ApplyTopicOverride(topic string) KafkaConfig { + out := *c + + override, ok := c.TopicOverrides[topic] + if !ok { + return out + } + + if override.OutputBatchCount != nil { + out.OutputBatchCount = *override.OutputBatchCount + } + + if override.OutputBatchPeriod != nil { + out.OutputBatchPeriod = *override.OutputBatchPeriod + } + + if override.MaxInFlight != nil { + out.MaxInFlight = *override.MaxInFlight + } + + return out +} + // heartbeatIntervalMs derives the heartbeat interval from the session timeout. // Kafka's standard practice is sessionTimeout / 10. func (c *KafkaConfig) heartbeatIntervalMs() int { @@ -158,10 +289,6 @@ func (c *SASLConfig) Validate() error { } } - if c.User == "" { - return errors.New("kafka.sasl: user is required") - } - if c.Password == "" && c.PasswordFile == "" { return errors.New("kafka.sasl: password or passwordFile is required") } @@ -170,5 +297,14 @@ func (c *SASLConfig) Validate() error { return errors.New("kafka.sasl: only one of password or passwordFile can be set") } + // OAUTHBEARER uses a token only; no username is required. + if mechanism == SASLMechanismOAUTHBEARER { + return nil + } + + if c.User == "" { + return errors.New("kafka.sasl: user is required") + } + return nil } diff --git a/pkg/consumoor/source/config_test.go b/pkg/consumoor/source/config_test.go index 0499f0c69..b111a6237 100644 --- a/pkg/consumoor/source/config_test.go +++ b/pkg/consumoor/source/config_test.go @@ -10,14 +10,108 @@ import ( func validKafkaConfig() KafkaConfig { return KafkaConfig{ - Brokers: []string{"localhost:9092"}, - Topics: []string{"test-topic"}, - ConsumerGroup: "test-group", - Encoding: "json", - OffsetDefault: "earliest", - SessionTimeoutMs: 30000, - CommitInterval: 5 * time.Second, - ShutdownTimeout: 30 * time.Second, + Brokers: []string{"localhost:9092"}, + Topics: []string{"test-topic"}, + ConsumerGroup: "test-group", + Encoding: "json", + OffsetDefault: "earliest", + SessionTimeoutMs: 30000, + RebalanceTimeout: 15 * time.Second, + CommitInterval: 5 * time.Second, + ShutdownTimeout: 30 * time.Second, + MaxInFlight: 64, + FetchMinBytes: 1, + FetchWaitMaxMs: 250, + MaxPartitionFetchBytes: 3145728, + FetchMaxBytes: 10485760, + } +} + +func intPtr(v int) *int { return &v } +func durPtr(v time.Duration) *time.Duration { return &v } + +func TestKafkaConfig_ApplyTopicOverride(t *testing.T) { + tests := []struct { + name string + overrides map[string]TopicOverride + topic string + wantCount int + wantPeriod time.Duration + wantFlight int + }{ + { + name: "no override returns unchanged copy", + overrides: nil, + topic: "general-beacon-block", + wantCount: 10000, + wantPeriod: 1 * time.Second, + wantFlight: 64, + }, + { + name: "partial override (only count)", + overrides: map[string]TopicOverride{ + "general-beacon-block": { + OutputBatchCount: intPtr(100), + }, + }, + topic: "general-beacon-block", + wantCount: 100, + wantPeriod: 1 * time.Second, + wantFlight: 64, + }, + { + name: "full override", + overrides: map[string]TopicOverride{ + "general-beacon-block": { + OutputBatchCount: intPtr(500), + OutputBatchPeriod: durPtr(200 * time.Millisecond), + MaxInFlight: intPtr(4), + }, + }, + topic: "general-beacon-block", + wantCount: 500, + wantPeriod: 200 * time.Millisecond, + wantFlight: 4, + }, + { + name: "explicit zero count", + overrides: map[string]TopicOverride{ + "general-beacon-block": { + OutputBatchCount: intPtr(0), + }, + }, + topic: "general-beacon-block", + wantCount: 0, + wantPeriod: 1 * time.Second, + wantFlight: 64, + }, + { + name: "unmatched topic returns unchanged copy", + overrides: map[string]TopicOverride{ + "general-beacon-attestation": { + OutputBatchCount: intPtr(50000), + }, + }, + topic: "general-beacon-block", + wantCount: 10000, + wantPeriod: 1 * time.Second, + wantFlight: 64, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := validKafkaConfig() + cfg.OutputBatchCount = 10000 + cfg.OutputBatchPeriod = 1 * time.Second + cfg.TopicOverrides = tt.overrides + + got := cfg.ApplyTopicOverride(tt.topic) + + assert.Equal(t, tt.wantCount, got.OutputBatchCount) + assert.Equal(t, tt.wantPeriod, got.OutputBatchPeriod) + assert.Equal(t, tt.wantFlight, got.MaxInFlight) + }) } } diff --git a/pkg/consumoor/source/dlq.go b/pkg/consumoor/source/dlq.go index 2c11e5ade..9d28623ba 100644 --- a/pkg/consumoor/source/dlq.go +++ b/pkg/consumoor/source/dlq.go @@ -31,20 +31,6 @@ type rejectSink interface { Enabled() bool } -type noopRejectSink struct{} - -func (noopRejectSink) Write(_ context.Context, _ *rejectedRecord) error { - return nil -} - -func (noopRejectSink) Close() error { - return nil -} - -func (noopRejectSink) Enabled() bool { - return false -} - type kafkaRejectSink struct { topic string cl *kgo.Client @@ -102,11 +88,11 @@ func (s *kafkaRejectSink) Write(ctx context.Context, record *rejectedRecord) err func newRejectSink(cfg *KafkaConfig) (rejectSink, error) { if cfg == nil { - return noopRejectSink{}, nil + return nil, nil } if strings.TrimSpace(cfg.RejectedTopic) == "" { - return noopRejectSink{}, nil + return nil, nil } opts := []kgo.Opt{ diff --git a/pkg/consumoor/source/kafka.go b/pkg/consumoor/source/kafka.go index 13bba05df..a14dff821 100644 --- a/pkg/consumoor/source/kafka.go +++ b/pkg/consumoor/source/kafka.go @@ -8,11 +8,12 @@ import ( "github.com/ethpandaops/xatu/pkg/proto/xatu" "google.golang.org/protobuf/encoding/protojson" - "google.golang.org/protobuf/proto" ) const unknownKafkaTopic = "unknown" +var jsonUnmarshalOpts = protojson.UnmarshalOptions{DiscardUnknown: true} + type kafkaMessageMetadata struct { Topic string Partition int32 @@ -93,16 +94,19 @@ func kafkaTopicMetadata(msg *service.Message) string { } func decodeDecoratedEvent(encoding string, data []byte) (*xatu.DecoratedEvent, error) { - event := &xatu.DecoratedEvent{} + event := xatu.DecoratedEventFromVTPool() switch encoding { case "protobuf": - if err := proto.Unmarshal(data, event); err != nil { + if err := event.UnmarshalVT(data); err != nil { + event.ReturnToVTPool() + return nil, fmt.Errorf("protobuf unmarshal: %w", err) } default: - opts := protojson.UnmarshalOptions{DiscardUnknown: true} - if err := opts.Unmarshal(data, event); err != nil { + if err := jsonUnmarshalOpts.Unmarshal(data, event); err != nil { + event.ReturnToVTPool() + return nil, fmt.Errorf("json unmarshal: %w", err) } } diff --git a/pkg/consumoor/source/lag_monitor.go b/pkg/consumoor/source/lag_monitor.go index b1701c91b..36532d3c1 100644 --- a/pkg/consumoor/source/lag_monitor.go +++ b/pkg/consumoor/source/lag_monitor.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "strconv" + "sync" "time" "github.com/twmb/franz-go/pkg/kadm" @@ -20,25 +21,33 @@ type LagMonitor struct { log logrus.FieldLogger metrics *telemetry.Metrics - interval time.Duration - consumerGroup string + interval time.Duration + consumerGroups []string admClient *kadm.Client kgoClient *kgo.Client done chan struct{} exited chan struct{} + stopOnce sync.Once } // NewLagMonitor creates a new LagMonitor. Call Start to begin polling. +// The consumerGroups slice contains the consumer group names to monitor +// for lag (one per-topic consumer group). func NewLagMonitor( log logrus.FieldLogger, cfg *KafkaConfig, + consumerGroups []string, metrics *telemetry.Metrics, ) (*LagMonitor, error) { if cfg == nil { return nil, fmt.Errorf("nil kafka config") } + if len(consumerGroups) == 0 { + return nil, fmt.Errorf("no consumer groups to monitor") + } + opts := []kgo.Opt{ kgo.SeedBrokers(cfg.Brokers...), } @@ -67,14 +76,14 @@ func NewLagMonitor( } return &LagMonitor{ - log: log.WithField("component", "lag_monitor"), - metrics: metrics, - interval: cfg.LagPollInterval, - consumerGroup: cfg.ConsumerGroup, - admClient: kadm.NewClient(kgoClient), - kgoClient: kgoClient, - done: make(chan struct{}), - exited: make(chan struct{}), + log: log.WithField("component", "lag_monitor"), + metrics: metrics, + interval: cfg.LagPollInterval, + consumerGroups: consumerGroups, + admClient: kadm.NewClient(kgoClient), + kgoClient: kgoClient, + done: make(chan struct{}), + exited: make(chan struct{}), }, nil } @@ -102,60 +111,70 @@ func (m *LagMonitor) Start(ctx context.Context) error { } // Stop signals the lag monitor to exit and waits for it to finish. +// It is safe to call multiple times; only the first call performs cleanup. func (m *LagMonitor) Stop() error { - close(m.done) - <-m.exited + m.stopOnce.Do(func() { + close(m.done) + <-m.exited - m.kgoClient.Close() + m.kgoClient.Close() + }) return nil } -// poll uses kadm.Client.Lag to fetch and publish consumer group lag. +// poll uses kadm.Client.Lag to fetch and publish consumer group lag +// for all monitored consumer groups. func (m *LagMonitor) poll(ctx context.Context) { - lags, err := m.admClient.Lag(ctx, m.consumerGroup) + lags, err := m.admClient.Lag(ctx, m.consumerGroups...) if err != nil { m.log.WithError(err).Warn("Failed to fetch consumer group lag") return } - groupLag, ok := lags[m.consumerGroup] - if !ok { - m.log.Debug("Consumer group not found in lag response") + for _, group := range m.consumerGroups { + groupLag, ok := lags[group] + if !ok { + m.log.WithField("consumer_group", group). + Debug("Consumer group not found in lag response") - return - } - - if groupLag.Error() != nil { - m.log.WithError(groupLag.Error()).Warn("Error in consumer group lag response") - - return - } - - for topic, partitions := range groupLag.Lag { - for partition := range partitions { - ml := partitions[partition] + continue + } - if ml.Err != nil { - m.log.WithError(ml.Err). - WithField("topic", topic). - WithField("partition", partition). - Warn("Error computing lag for partition") + if groupLag.Error() != nil { + m.log.WithError(groupLag.Error()). + WithField("consumer_group", group). + Warn("Error in consumer group lag response") - continue - } + continue + } - lag := ml.Lag - if lag < 0 { - lag = 0 + for topic, partitions := range groupLag.Lag { + for partition := range partitions { + ml := partitions[partition] + + if ml.Err != nil { + m.log.WithError(ml.Err). + WithField("topic", topic). + WithField("partition", partition). + WithField("consumer_group", group). + Warn("Error computing lag for partition") + + continue + } + + lag := ml.Lag + if lag < 0 { + lag = 0 + } + + m.metrics.KafkaConsumerLag().WithLabelValues( + topic, + strconv.FormatInt(int64(partition), 10), + group, + ).Set(float64(lag)) } - - m.metrics.KafkaConsumerLag().WithLabelValues( - topic, - strconv.FormatInt(int64(partition), 10), - m.consumerGroup, - ).Set(float64(lag)) } } } diff --git a/pkg/consumoor/source/output.go b/pkg/consumoor/source/output.go index 650963ca9..0587809a3 100644 --- a/pkg/consumoor/source/output.go +++ b/pkg/consumoor/source/output.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "sync" + "time" "github.com/redpanda-data/benthos/v4/public/service" @@ -19,6 +20,7 @@ const ( rejectReasonDecode = "decode_error" rejectReasonRouteRejected = "route_rejected" rejectReasonWritePermanent = "write_permanent" + rejectReasonInvalidEvent = "invalid_event" ) var errBatchWriteFailed = errors.New("clickhouse batch write failed") @@ -38,13 +40,20 @@ type eventGroup struct { } type xatuClickHouseOutput struct { - log logrus.FieldLogger - encoding string - router *router.Engine - writer Writer - metrics *telemetry.Metrics - rejectSink rejectSink - ownsWriter bool + log logrus.FieldLogger + encoding string + router *router.Engine + writer Writer + metrics *telemetry.Metrics + rejectSink rejectSink + ownsWriter bool + outputBatchCount int + logSampler *telemetry.LogSampler + + // Group-level retry config for partial table failures. + groupRetryMaxAttempts int + groupRetryBaseDelay time.Duration + groupRetryMaxDelay time.Duration mu sync.Mutex started bool @@ -83,8 +92,27 @@ func (o *xatuClickHouseOutput) WriteBatch( return ctx.Err() } + // Record which trigger caused this batch flush. + // Each Benthos stream is per-topic, so the first message's topic is + // representative of the entire batch. + topic := kafkaMetadata(msgs[0]).Topic + + trigger := "timeout" + if o.outputBatchCount > 0 && len(msgs) >= o.outputBatchCount { + trigger = "count" + } + + o.metrics.BatchFlushTrigger().WithLabelValues(topic, trigger).Inc() + var batchErr *service.BatchError + var pooledEvents []*xatu.DecoratedEvent + defer func() { + for _, ev := range pooledEvents { + ev.ReturnToVTPool() + } + }() + groups := make(map[xatu.Event_Name]*eventGroup, 16) // Phase 1: decode, route, and group by event type. @@ -95,9 +123,18 @@ func (o *xatuClickHouseOutput) WriteBatch( raw, err := msg.AsBytes() if err != nil { o.metrics.DecodeErrors().WithLabelValues(kafka.Topic).Inc() - o.log.WithError(err). - WithField("topic", kafka.Topic). - Warn("Failed to read message bytes") + + if ok, suppressed := o.logSampler.Allow("read_bytes:" + kafka.Topic); ok { + entry := o.log.WithError(err). + WithField("topic", kafka.Topic). + WithField("partition", kafka.Partition). + WithField("offset", kafka.Offset) + if suppressed > 0 { + entry = entry.WithField("suppressed", suppressed) + } + + entry.Warn("Failed to read message bytes") + } if rejectErr := o.rejectMessage(ctx, &rejectedRecord{ Reason: rejectReasonDecode, @@ -113,9 +150,18 @@ func (o *xatuClickHouseOutput) WriteBatch( event, err := decodeDecoratedEvent(o.encoding, raw) if err != nil { o.metrics.DecodeErrors().WithLabelValues(kafka.Topic).Inc() - o.log.WithError(err). - WithField("topic", kafka.Topic). - Warn("Failed to decode message") + + if ok, suppressed := o.logSampler.Allow("decode:" + kafka.Topic); ok { + entry := o.log.WithError(err). + WithField("topic", kafka.Topic). + WithField("partition", kafka.Partition). + WithField("offset", kafka.Offset) + if suppressed > 0 { + entry = entry.WithField("suppressed", suppressed) + } + + entry.Warn("Failed to decode message") + } if rejectErr := o.rejectMessage(ctx, &rejectedRecord{ Reason: rejectReasonDecode, @@ -129,6 +175,8 @@ func (o *xatuClickHouseOutput) WriteBatch( continue } + pooledEvents = append(pooledEvents, event) + outcome := o.router.Route(event) if outcome.Status == router.StatusRejected { @@ -147,7 +195,10 @@ func (o *xatuClickHouseOutput) WriteBatch( if outcome.Status == router.StatusErrored { batchErr = addBatchFailure( - batchErr, msgs, i, errors.New("route errored"), + batchErr, msgs, i, fmt.Errorf( + "no route registered for event %s — offset will not advance until a route is deployed", + event.GetEvent().GetName(), + ), ) continue @@ -174,7 +225,7 @@ func (o *xatuClickHouseOutput) WriteBatch( g.messages = append(g.messages, groupMessage{ batchIndex: i, - raw: append([]byte(nil), raw...), + raw: raw, event: event, kafka: kafka, tables: tables, @@ -182,10 +233,11 @@ func (o *xatuClickHouseOutput) WriteBatch( } // Phase 2: process each event group independently. + // Pass batchErr through so Phase 1 failures (decode errors) are preserved + // when a group also fails — otherwise processGroup would create a new + // BatchError that silently drops the earlier failures. for _, g := range groups { - if err := o.processGroup(ctx, msgs, g); err != nil { - batchErr = err - } + batchErr = o.processGroup(ctx, msgs, batchErr, g) } if batchErr != nil { @@ -226,43 +278,118 @@ func (o *xatuClickHouseOutput) Close(ctx context.Context) error { // processGroup writes all messages in the group to their target tables, then // flushes only those tables. On failure the entire group is NAK'd or DLQ'd. +// The caller's accumulated batchErr is threaded through so that failures from +// earlier phases (e.g. decode errors) are preserved. +// +// For events that fan out to multiple tables, partial failures (some tables +// succeed, others fail transiently) are retried with exponential backoff. +// Only the failed tables are retried to prevent duplicate writes on already- +// succeeded tables. func (o *xatuClickHouseOutput) processGroup( ctx context.Context, msgs service.MessageBatch, + batchErr *service.BatchError, g *eventGroup, ) *service.BatchError { - // Collect the unique set of tables for this group. - tableSet := make(map[string]struct{}, 4) - + tableEvents := make(map[string][]*xatu.DecoratedEvent, 4) for _, gm := range g.messages { for _, table := range gm.tables { - tableSet[table] = struct{}{} + tableEvents[table] = append(tableEvents[table], gm.event) } + } - for _, table := range gm.tables { - o.writer.Write(table, gm.event) + var ( + allInvalidEvents []*xatu.DecoratedEvent + lastResult *clickhouse.FlushResult + ) + + // Group-level retry loop for partial table failures. + for attempt := range o.groupRetryMaxAttempts + 1 { + if attempt > 0 && len(tableEvents) > 0 { + delay := min( + o.groupRetryBaseDelay*time.Duration(1<<(attempt-1)), + o.groupRetryMaxDelay, + ) + + o.log.WithFields(logrus.Fields{ + "attempt": attempt, + "max_attempts": o.groupRetryMaxAttempts, + "delay": delay, + "failed_tables": len(tableEvents), + }).Warn("Retrying failed tables with backoff") + + o.metrics.GroupRetries().WithLabelValues( + g.messages[0].event.GetEvent().GetName().String(), + ).Inc() + + select { + case <-ctx.Done(): + for _, gm := range g.messages { + batchErr = addBatchFailure(batchErr, msgs, gm.batchIndex, ctx.Err()) + } + + return batchErr + case <-time.After(delay): + } + } + + result := o.writer.FlushTableEvents(ctx, tableEvents) + lastResult = result + + if len(result.InvalidEvents) > 0 { + allInvalidEvents = append(allInvalidEvents, result.InvalidEvents...) + } + + // All tables succeeded. + if len(result.TableErrors) == 0 { + break } - } - tables := make([]string, 0, len(tableSet)) - for t := range tableSet { - tables = append(tables, t) + // Check if any failures are permanent — don't retry those. + anyTransient := false + + for _, tErr := range result.TableErrors { + if !clickhouse.IsPermanentWriteError(tErr) { + anyTransient = true + + break + } + } + + if !anyTransient { + break + } + + // Remove succeeded tables from the retry set. + remaining := make(map[string][]*xatu.DecoratedEvent, len(result.TableErrors)) + + for table := range result.TableErrors { + if events, ok := tableEvents[table]; ok { + remaining[table] = events + } + } + + tableEvents = remaining } - err := o.writer.FlushTables(ctx, tables) + // DLQ invalid events individually. Deduplicate by event pointer since + // the same event can appear in multiple tables' invalid lists due to fanout. + batchErr = o.dlqInvalidEvents(ctx, msgs, batchErr, g, allInvalidEvents) + + err := lastResult.Err() if err == nil { - return nil + return batchErr } // Flush failed — attribute to all messages in the group. - var batchErr *service.BatchError - if clickhouse.IsPermanentWriteError(err) { for _, gm := range g.messages { + // Copy raw bytes only when needed for DLQ; the success path + // avoids the copy entirely by referencing the Benthos-owned slice. rejectErr := o.rejectMessage(ctx, &rejectedRecord{ Reason: rejectReasonWritePermanent, Err: err.Error(), - Payload: gm.raw, + Payload: append([]byte(nil), gm.raw...), EventName: gm.event.GetEvent().GetName().String(), Kafka: gm.kafka, }) @@ -274,7 +401,8 @@ func (o *xatuClickHouseOutput) processGroup( } o.log.WithError(err). - Warn("Dropped permanently invalid rows during group flush") + WithField("dlq_enabled", o.rejectSink != nil && o.rejectSink.Enabled()). + Warn("Permanent write error during group flush") } else { for _, gm := range g.messages { batchErr = addBatchFailure( @@ -286,6 +414,51 @@ func (o *xatuClickHouseOutput) processGroup( return batchErr } +// dlqInvalidEvents sends invalid events to the DLQ, deduplicating by event +// pointer to handle fanout where the same event appears in multiple tables. +func (o *xatuClickHouseOutput) dlqInvalidEvents( + ctx context.Context, + msgs service.MessageBatch, + batchErr *service.BatchError, + g *eventGroup, + invalidEvents []*xatu.DecoratedEvent, +) *service.BatchError { + if len(invalidEvents) == 0 { + return batchErr + } + + seen := make(map[*xatu.DecoratedEvent]struct{}, len(invalidEvents)) + + for _, ev := range invalidEvents { + if _, dup := seen[ev]; dup { + continue + } + + seen[ev] = struct{}{} + + for _, gm := range g.messages { + if gm.event != ev { + continue + } + + rejectErr := o.rejectMessage(ctx, &rejectedRecord{ + Reason: rejectReasonInvalidEvent, + Err: "invalid event: permanently unflattenable", + Payload: append([]byte(nil), gm.raw...), + EventName: ev.GetEvent().GetName().String(), + Kafka: gm.kafka, + }) + if rejectErr != nil { + batchErr = addBatchFailure(batchErr, msgs, gm.batchIndex, rejectErr) + } + + break + } + } + + return batchErr +} + func (o *xatuClickHouseOutput) rejectMessage( ctx context.Context, record *rejectedRecord, @@ -303,9 +476,11 @@ func (o *xatuClickHouseOutput) rejectMessage( return nil } - // For all other reasons (decode errors, permanent write failures) - // failing the message forces Kafka to redeliver rather than - // silently dropping data when no DLQ is configured. + // For all other reasons (decode errors, permanent write failures, + // invalid events) failing the message forces Kafka to redeliver + // rather than silently dropping data when no DLQ is configured. + // Invalid events may become valid after a rolling deploy where a + // newer version adds support for new fields or event subtypes. return fmt.Errorf("no DLQ configured for rejected message (%s): %s", record.Reason, record.Err) } diff --git a/pkg/consumoor/source/writer.go b/pkg/consumoor/source/writer.go index c3c96a4ad..547a10856 100644 --- a/pkg/consumoor/source/writer.go +++ b/pkg/consumoor/source/writer.go @@ -3,6 +3,7 @@ package source import ( "context" + "github.com/ethpandaops/xatu/pkg/consumoor/clickhouse" "github.com/ethpandaops/xatu/pkg/proto/xatu" ) @@ -10,11 +11,11 @@ import ( type Writer interface { Start(ctx context.Context) error Stop(ctx context.Context) error - Write(table string, event *xatu.DecoratedEvent) - // FlushTables forces the specified table writers (by base table name) - // to drain their buffers and write to ClickHouse synchronously. - // An empty or nil slice is a no-op that returns nil. - FlushTables(ctx context.Context, tables []string) error + // FlushTableEvents writes the given events directly to their respective + // ClickHouse tables concurrently. The map keys are base table names + // (without suffix). Returns a FlushResult containing per-table errors + // and any invalid events that should be sent to the DLQ. + FlushTableEvents(ctx context.Context, tableEvents map[string][]*xatu.DecoratedEvent) *clickhouse.FlushResult // Ping checks connectivity to the underlying datastore. Ping(ctx context.Context) error } diff --git a/pkg/consumoor/telemetry/log_sampler.go b/pkg/consumoor/telemetry/log_sampler.go new file mode 100644 index 000000000..c721078a0 --- /dev/null +++ b/pkg/consumoor/telemetry/log_sampler.go @@ -0,0 +1,60 @@ +package telemetry + +import ( + "sync" + "time" +) + +// LogSampler gates log emission so that at most one log is emitted per +// interval for each unique key. Callers use Allow() to check whether a +// log should be written; suppressed occurrences are counted and reported +// when the next log is allowed. +// +// Keys should be bounded (e.g. event names, table names, topic names) +// so that the internal map does not grow unboundedly. +type LogSampler struct { + interval time.Duration + mu sync.Mutex + entries map[string]*sampledEntry +} + +type sampledEntry struct { + lastEmit time.Time + suppressed int64 +} + +// NewLogSampler creates a sampler that allows one log per interval per key. +func NewLogSampler(interval time.Duration) *LogSampler { + return &LogSampler{ + interval: interval, + entries: make(map[string]*sampledEntry), + } +} + +// Allow returns whether a log should be emitted for the given key, and +// the number of occurrences suppressed since the last emission. +func (s *LogSampler) Allow(key string) (bool, int64) { + now := time.Now() + + s.mu.Lock() + defer s.mu.Unlock() + + entry, ok := s.entries[key] + if !ok { + s.entries[key] = &sampledEntry{lastEmit: now} + + return true, 0 + } + + if now.Sub(entry.lastEmit) < s.interval { + entry.suppressed++ + + return false, 0 + } + + suppressed := entry.suppressed + entry.suppressed = 0 + entry.lastEmit = now + + return true, suppressed +} diff --git a/pkg/consumoor/telemetry/log_sampler_test.go b/pkg/consumoor/telemetry/log_sampler_test.go new file mode 100644 index 000000000..68f53c06c --- /dev/null +++ b/pkg/consumoor/telemetry/log_sampler_test.go @@ -0,0 +1,112 @@ +package telemetry + +import ( + "testing" + "time" +) + +func TestLogSampler_FirstCallAlwaysAllowed(t *testing.T) { + s := NewLogSampler(time.Hour) // large interval so nothing expires + + ok, suppressed := s.Allow("key1") + if !ok { + t.Fatal("first call should be allowed") + } + + if suppressed != 0 { + t.Fatalf("first call should have 0 suppressed, got %d", suppressed) + } +} + +func TestLogSampler_SuppressesWithinInterval(t *testing.T) { + s := NewLogSampler(time.Hour) + + s.Allow("key1") // first — allowed + + ok, _ := s.Allow("key1") + if ok { + t.Fatal("second call within interval should be suppressed") + } + + ok, _ = s.Allow("key1") + if ok { + t.Fatal("third call within interval should be suppressed") + } +} + +func TestLogSampler_DifferentKeysIndependent(t *testing.T) { + s := NewLogSampler(time.Hour) + + s.Allow("key1") + + ok, suppressed := s.Allow("key2") + if !ok { + t.Fatal("different key should be allowed") + } + + if suppressed != 0 { + t.Fatalf("different key should have 0 suppressed, got %d", suppressed) + } +} + +func TestLogSampler_ReportsSuppressedCount(t *testing.T) { + s := NewLogSampler(50 * time.Millisecond) + + s.Allow("key1") + + // Suppress 3 occurrences. + s.Allow("key1") + s.Allow("key1") + s.Allow("key1") + + // Wait for interval to expire. + time.Sleep(60 * time.Millisecond) + + ok, suppressed := s.Allow("key1") + if !ok { + t.Fatal("call after interval should be allowed") + } + + if suppressed != 3 { + t.Fatalf("expected 3 suppressed, got %d", suppressed) + } + + // Next call within new interval should suppress again. + ok, _ = s.Allow("key1") + if ok { + t.Fatal("call within new interval should be suppressed") + } +} + +func TestLogSampler_SuppressedCountResets(t *testing.T) { + s := NewLogSampler(50 * time.Millisecond) + + s.Allow("key1") + s.Allow("key1") // +1 suppressed + + time.Sleep(60 * time.Millisecond) + + // Drains the suppressed count. + ok, suppressed := s.Allow("key1") + if !ok { + t.Fatal("should be allowed") + } + + if suppressed != 1 { + t.Fatalf("expected 1 suppressed, got %d", suppressed) + } + + // Immediately suppress again — count should be fresh. + s.Allow("key1") + + time.Sleep(60 * time.Millisecond) + + ok, suppressed = s.Allow("key1") + if !ok { + t.Fatal("should be allowed") + } + + if suppressed != 1 { + t.Fatalf("expected 1 suppressed after reset, got %d", suppressed) + } +} diff --git a/pkg/consumoor/telemetry/metrics.go b/pkg/consumoor/telemetry/metrics.go index bd08af760..458ff4ee7 100644 --- a/pkg/consumoor/telemetry/metrics.go +++ b/pkg/consumoor/telemetry/metrics.go @@ -7,22 +7,31 @@ import ( // Metrics holds all Prometheus metrics for the consumoor service. type Metrics struct { - messagesConsumed *prometheus.CounterVec - messagesRouted *prometheus.CounterVec - messagesDropped *prometheus.CounterVec - messagesRejected *prometheus.CounterVec - decodeErrors *prometheus.CounterVec - dlqWrites *prometheus.CounterVec - dlqErrors *prometheus.CounterVec - rowsWritten *prometheus.CounterVec - writeErrors *prometheus.CounterVec - writeDuration *prometheus.HistogramVec - batchSize *prometheus.HistogramVec - bufferUsage *prometheus.GaugeVec - bufferUsageTotal prometheus.Gauge - flattenErrors *prometheus.CounterVec - activeTopics prometheus.Gauge - kafkaConsumerLag *prometheus.GaugeVec + messagesConsumed *prometheus.CounterVec + messagesRouted *prometheus.CounterVec + messagesDropped *prometheus.CounterVec + messagesRejected *prometheus.CounterVec + decodeErrors *prometheus.CounterVec + dlqWrites *prometheus.CounterVec + dlqErrors *prometheus.CounterVec + rowsWritten *prometheus.CounterVec + writeErrors *prometheus.CounterVec + writeDuration *prometheus.HistogramVec + batchSize *prometheus.HistogramVec + flattenErrors *prometheus.CounterVec + eventLag *prometheus.HistogramVec + batchFlushTrigger *prometheus.CounterVec + activeTopics prometheus.Gauge + kafkaConsumerLag *prometheus.GaugeVec + outputMaxInFlight *prometheus.GaugeVec + writeRetries *prometheus.CounterVec + groupRetries *prometheus.CounterVec + + // adaptive limiter metrics (per-table) + adaptiveLimiterLimit *prometheus.GaugeVec + adaptiveLimiterInflight *prometheus.GaugeVec + adaptiveLimiterQueued *prometheus.GaugeVec + adaptiveLimiterRejections *prometheus.CounterVec // ch-go pool metrics chgoPoolAcquiredResources prometheus.Gauge @@ -125,26 +134,27 @@ func NewMetrics(namespace string) *Metrics { Buckets: []float64{1, 10, 100, 1000, 10000, 50000, 100000, 200000, 500000, 1000000}, }, []string{"table"}), - bufferUsage: promauto.NewGaugeVec(prometheus.GaugeOpts{ + flattenErrors: promauto.NewCounterVec(prometheus.CounterOpts{ Namespace: namespace, Subsystem: subsystem, - Name: "buffer_usage", - Help: "Current number of rows buffered per table.", - }, []string{"table"}), + Name: "flatten_errors_total", + Help: "Total number of flattener errors.", + }, []string{"event_name", "table"}), - bufferUsageTotal: promauto.NewGauge(prometheus.GaugeOpts{ + eventLag: promauto.NewHistogramVec(prometheus.HistogramOpts{ Namespace: namespace, Subsystem: subsystem, - Name: "buffer_usage_total", - Help: "Sum of all table buffer usages. Single number for aggregate memory pressure alerting.", - }), + Name: "event_lag_seconds", + Help: "Lag between the event timestamp and the wall clock time at routing.", + Buckets: []float64{1, 5, 10, 30, 60, 120, 300, 600, 1800, 3600, 7200, 14400}, + }, []string{"event_name"}), - flattenErrors: promauto.NewCounterVec(prometheus.CounterOpts{ + batchFlushTrigger: promauto.NewCounterVec(prometheus.CounterOpts{ Namespace: namespace, Subsystem: subsystem, - Name: "flatten_errors_total", - Help: "Total number of flattener errors.", - }, []string{"event_name", "table"}), + Name: "batch_flush_trigger_total", + Help: "Total number of batch flushes by trigger type (count or timeout).", + }, []string{"topic", "trigger"}), activeTopics: promauto.NewGauge(prometheus.GaugeOpts{ Namespace: namespace, @@ -160,6 +170,55 @@ func NewMetrics(namespace string) *Metrics { Help: "Kafka consumer group lag per topic and partition.", }, []string{"topic", "partition", "consumer_group"}), + outputMaxInFlight: promauto.NewGaugeVec(prometheus.GaugeOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "output_max_in_flight", + Help: "Configured maximum number of concurrent Benthos WriteBatch calls per stream.", + }, []string{"topic"}), + + adaptiveLimiterLimit: promauto.NewGaugeVec(prometheus.GaugeOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "adaptive_limiter_limit", + Help: "Current adaptive concurrency limit per table.", + }, []string{"table"}), + + adaptiveLimiterInflight: promauto.NewGaugeVec(prometheus.GaugeOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "adaptive_limiter_inflight", + Help: "Current number of in-flight permits per table.", + }, []string{"table"}), + + adaptiveLimiterQueued: promauto.NewGaugeVec(prometheus.GaugeOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "adaptive_limiter_queued", + Help: "Current number of queued permit requests per table.", + }, []string{"table"}), + + adaptiveLimiterRejections: promauto.NewCounterVec(prometheus.CounterOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "adaptive_limiter_rejections_total", + Help: "Total number of requests rejected by the adaptive concurrency limiter.", + }, []string{"table"}), + + writeRetries: promauto.NewCounterVec(prometheus.CounterOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "write_retries_total", + Help: "Total number of ch-go operation retry attempts after transient errors.", + }, []string{"operation"}), + + groupRetries: promauto.NewCounterVec(prometheus.CounterOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "group_retries_total", + Help: "Total number of group-level retry attempts for partial table failures.", + }, []string{"event_name"}), + chgoPoolAcquiredResources: promauto.NewGauge(prometheus.GaugeOpts{ Namespace: namespace, Subsystem: subsystem, @@ -232,22 +291,32 @@ func NewMetrics(namespace string) *Metrics { } } -func (m *Metrics) MessagesConsumed() *prometheus.CounterVec { return m.messagesConsumed } -func (m *Metrics) MessagesRouted() *prometheus.CounterVec { return m.messagesRouted } -func (m *Metrics) MessagesDropped() *prometheus.CounterVec { return m.messagesDropped } -func (m *Metrics) MessagesRejected() *prometheus.CounterVec { return m.messagesRejected } -func (m *Metrics) DecodeErrors() *prometheus.CounterVec { return m.decodeErrors } -func (m *Metrics) DLQWrites() *prometheus.CounterVec { return m.dlqWrites } -func (m *Metrics) DLQErrors() *prometheus.CounterVec { return m.dlqErrors } -func (m *Metrics) RowsWritten() *prometheus.CounterVec { return m.rowsWritten } -func (m *Metrics) WriteErrors() *prometheus.CounterVec { return m.writeErrors } -func (m *Metrics) WriteDuration() *prometheus.HistogramVec { return m.writeDuration } -func (m *Metrics) BatchSize() *prometheus.HistogramVec { return m.batchSize } -func (m *Metrics) BufferUsage() *prometheus.GaugeVec { return m.bufferUsage } -func (m *Metrics) BufferUsageTotal() prometheus.Gauge { return m.bufferUsageTotal } -func (m *Metrics) FlattenErrors() *prometheus.CounterVec { return m.flattenErrors } -func (m *Metrics) ActiveTopics() prometheus.Gauge { return m.activeTopics } -func (m *Metrics) KafkaConsumerLag() *prometheus.GaugeVec { return m.kafkaConsumerLag } +func (m *Metrics) MessagesConsumed() *prometheus.CounterVec { return m.messagesConsumed } +func (m *Metrics) MessagesRouted() *prometheus.CounterVec { return m.messagesRouted } +func (m *Metrics) MessagesDropped() *prometheus.CounterVec { return m.messagesDropped } +func (m *Metrics) MessagesRejected() *prometheus.CounterVec { return m.messagesRejected } +func (m *Metrics) DecodeErrors() *prometheus.CounterVec { return m.decodeErrors } +func (m *Metrics) DLQWrites() *prometheus.CounterVec { return m.dlqWrites } +func (m *Metrics) DLQErrors() *prometheus.CounterVec { return m.dlqErrors } +func (m *Metrics) RowsWritten() *prometheus.CounterVec { return m.rowsWritten } +func (m *Metrics) WriteErrors() *prometheus.CounterVec { return m.writeErrors } +func (m *Metrics) WriteDuration() *prometheus.HistogramVec { return m.writeDuration } +func (m *Metrics) BatchSize() *prometheus.HistogramVec { return m.batchSize } +func (m *Metrics) FlattenErrors() *prometheus.CounterVec { return m.flattenErrors } +func (m *Metrics) EventLag() *prometheus.HistogramVec { return m.eventLag } +func (m *Metrics) BatchFlushTrigger() *prometheus.CounterVec { return m.batchFlushTrigger } +func (m *Metrics) ActiveTopics() prometheus.Gauge { return m.activeTopics } +func (m *Metrics) KafkaConsumerLag() *prometheus.GaugeVec { return m.kafkaConsumerLag } +func (m *Metrics) OutputMaxInFlight() *prometheus.GaugeVec { return m.outputMaxInFlight } + +func (m *Metrics) AdaptiveLimiterLimit() *prometheus.GaugeVec { return m.adaptiveLimiterLimit } +func (m *Metrics) AdaptiveLimiterInflight() *prometheus.GaugeVec { return m.adaptiveLimiterInflight } +func (m *Metrics) AdaptiveLimiterQueued() *prometheus.GaugeVec { return m.adaptiveLimiterQueued } +func (m *Metrics) AdaptiveLimiterRejections() *prometheus.CounterVec { + return m.adaptiveLimiterRejections +} +func (m *Metrics) WriteRetries() *prometheus.CounterVec { return m.writeRetries } +func (m *Metrics) GroupRetries() *prometheus.CounterVec { return m.groupRetries } func (m *Metrics) ChgoPoolAcquiredResources() prometheus.Gauge { return m.chgoPoolAcquiredResources } func (m *Metrics) ChgoPoolIdleResources() prometheus.Gauge { return m.chgoPoolIdleResources } diff --git a/pkg/proto/eth/v1/attestation_vtproto.pb.go b/pkg/proto/eth/v1/attestation_vtproto.pb.go new file mode 100644 index 000000000..f1628066a --- /dev/null +++ b/pkg/proto/eth/v1/attestation_vtproto.pb.go @@ -0,0 +1,2300 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/attestation.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *Attestation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Attestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Attestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Data != nil { + size, err := m.Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if len(m.AggregationBits) > 0 { + i -= len(m.AggregationBits) + copy(dAtA[i:], m.AggregationBits) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AggregationBits))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AttestationV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AttestationV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AttestationV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Data != nil { + size, err := m.Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if len(m.AggregationBits) > 0 { + i -= len(m.AggregationBits) + copy(dAtA[i:], m.AggregationBits) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AggregationBits))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AttestationData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AttestationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AttestationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Target != nil { + size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.BeaconBlockRoot) > 0 { + i -= len(m.BeaconBlockRoot) + copy(dAtA[i:], m.BeaconBlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BeaconBlockRoot))) + i-- + dAtA[i] = 0x1a + } + if m.Index != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AttestationDataV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AttestationDataV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AttestationDataV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Target != nil { + size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.BeaconBlockRoot) > 0 { + i -= len(m.BeaconBlockRoot) + copy(dAtA[i:], m.BeaconBlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BeaconBlockRoot))) + i-- + dAtA[i] = 0x1a + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AggregateAttestationAndProof) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AggregateAttestationAndProof) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AggregateAttestationAndProof) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Aggregate != nil { + size, err := m.Aggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if len(m.SelectionProof) > 0 { + i -= len(m.SelectionProof) + copy(dAtA[i:], m.SelectionProof) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SelectionProof))) + i-- + dAtA[i] = 0x12 + } + if m.AggregatorIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.AggregatorIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SignedAggregateAttestationAndProof) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedAggregateAttestationAndProof) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedAggregateAttestationAndProof) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AggregateAttestationAndProofV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AggregateAttestationAndProofV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AggregateAttestationAndProofV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Aggregate != nil { + size, err := m.Aggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.AggregatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.AggregatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedAggregateAttestationAndProofV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedAggregateAttestationAndProofV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedAggregateAttestationAndProofV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ElaboratedAttestation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ElaboratedAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ElaboratedAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ValidatorIndexes) > 0 { + for iNdEx := len(m.ValidatorIndexes) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorIndexes[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if m.Data != nil { + size, err := m.Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_Attestation = sync.Pool{ + New: func() interface{} { + return &Attestation{} + }, +} + +func (m *Attestation) ResetVT() { + if m != nil { + m.Data.ReturnToVTPool() + m.Reset() + } +} +func (m *Attestation) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Attestation.Put(m) + } +} +func AttestationFromVTPool() *Attestation { + return vtprotoPool_Attestation.Get().(*Attestation) +} + +var vtprotoPool_AttestationV2 = sync.Pool{ + New: func() interface{} { + return &AttestationV2{} + }, +} + +func (m *AttestationV2) ResetVT() { + if m != nil { + m.Data.ReturnToVTPool() + m.Reset() + } +} +func (m *AttestationV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AttestationV2.Put(m) + } +} +func AttestationV2FromVTPool() *AttestationV2 { + return vtprotoPool_AttestationV2.Get().(*AttestationV2) +} + +var vtprotoPool_AttestationData = sync.Pool{ + New: func() interface{} { + return &AttestationData{} + }, +} + +func (m *AttestationData) ResetVT() { + if m != nil { + m.Source.ReturnToVTPool() + m.Target.ReturnToVTPool() + m.Reset() + } +} +func (m *AttestationData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AttestationData.Put(m) + } +} +func AttestationDataFromVTPool() *AttestationData { + return vtprotoPool_AttestationData.Get().(*AttestationData) +} + +var vtprotoPool_AttestationDataV2 = sync.Pool{ + New: func() interface{} { + return &AttestationDataV2{} + }, +} + +func (m *AttestationDataV2) ResetVT() { + if m != nil { + m.Source.ReturnToVTPool() + m.Target.ReturnToVTPool() + m.Reset() + } +} +func (m *AttestationDataV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AttestationDataV2.Put(m) + } +} +func AttestationDataV2FromVTPool() *AttestationDataV2 { + return vtprotoPool_AttestationDataV2.Get().(*AttestationDataV2) +} + +var vtprotoPool_AggregateAttestationAndProof = sync.Pool{ + New: func() interface{} { + return &AggregateAttestationAndProof{} + }, +} + +func (m *AggregateAttestationAndProof) ResetVT() { + if m != nil { + m.Aggregate.ReturnToVTPool() + m.Reset() + } +} +func (m *AggregateAttestationAndProof) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AggregateAttestationAndProof.Put(m) + } +} +func AggregateAttestationAndProofFromVTPool() *AggregateAttestationAndProof { + return vtprotoPool_AggregateAttestationAndProof.Get().(*AggregateAttestationAndProof) +} + +var vtprotoPool_SignedAggregateAttestationAndProof = sync.Pool{ + New: func() interface{} { + return &SignedAggregateAttestationAndProof{} + }, +} + +func (m *SignedAggregateAttestationAndProof) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedAggregateAttestationAndProof) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedAggregateAttestationAndProof.Put(m) + } +} +func SignedAggregateAttestationAndProofFromVTPool() *SignedAggregateAttestationAndProof { + return vtprotoPool_SignedAggregateAttestationAndProof.Get().(*SignedAggregateAttestationAndProof) +} + +var vtprotoPool_AggregateAttestationAndProofV2 = sync.Pool{ + New: func() interface{} { + return &AggregateAttestationAndProofV2{} + }, +} + +func (m *AggregateAttestationAndProofV2) ResetVT() { + if m != nil { + m.Aggregate.ReturnToVTPool() + m.Reset() + } +} +func (m *AggregateAttestationAndProofV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AggregateAttestationAndProofV2.Put(m) + } +} +func AggregateAttestationAndProofV2FromVTPool() *AggregateAttestationAndProofV2 { + return vtprotoPool_AggregateAttestationAndProofV2.Get().(*AggregateAttestationAndProofV2) +} + +var vtprotoPool_SignedAggregateAttestationAndProofV2 = sync.Pool{ + New: func() interface{} { + return &SignedAggregateAttestationAndProofV2{} + }, +} + +func (m *SignedAggregateAttestationAndProofV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedAggregateAttestationAndProofV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedAggregateAttestationAndProofV2.Put(m) + } +} +func SignedAggregateAttestationAndProofV2FromVTPool() *SignedAggregateAttestationAndProofV2 { + return vtprotoPool_SignedAggregateAttestationAndProofV2.Get().(*SignedAggregateAttestationAndProofV2) +} + +var vtprotoPool_ElaboratedAttestation = sync.Pool{ + New: func() interface{} { + return &ElaboratedAttestation{} + }, +} + +func (m *ElaboratedAttestation) ResetVT() { + if m != nil { + m.Data.ReturnToVTPool() + for _, mm := range m.ValidatorIndexes { + mm.Reset() + } + f0 := m.ValidatorIndexes[:0] + m.Reset() + m.ValidatorIndexes = f0 + } +} +func (m *ElaboratedAttestation) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ElaboratedAttestation.Put(m) + } +} +func ElaboratedAttestationFromVTPool() *ElaboratedAttestation { + return vtprotoPool_ElaboratedAttestation.Get().(*ElaboratedAttestation) +} +func (m *Attestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.AggregationBits) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Data != nil { + l = m.Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AttestationV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.AggregationBits) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Data != nil { + l = m.Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AttestationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.Index != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Index)) + } + l = len(m.BeaconBlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Target != nil { + l = m.Target.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AttestationDataV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BeaconBlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Target != nil { + l = m.Target.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AggregateAttestationAndProof) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AggregatorIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.AggregatorIndex)) + } + l = len(m.SelectionProof) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Aggregate != nil { + l = m.Aggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedAggregateAttestationAndProof) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AggregateAttestationAndProofV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AggregatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.AggregatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Aggregate != nil { + l = m.Aggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedAggregateAttestationAndProofV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ElaboratedAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Data != nil { + l = m.Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ValidatorIndexes) > 0 { + for _, e := range m.ValidatorIndexes { + l = (*wrapperspb.UInt64Value)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *Attestation) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Attestation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Attestation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregationBits", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AggregationBits = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = AttestationDataFromVTPool() + } + if err := m.Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AttestationV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AttestationV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AttestationV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregationBits", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AggregationBits = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = AttestationDataV2FromVTPool() + } + if err := m.Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AttestationData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AttestationData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AttestationData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BeaconBlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = CheckpointFromVTPool() + } + if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Target == nil { + m.Target = CheckpointFromVTPool() + } + if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AttestationDataV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AttestationDataV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AttestationDataV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BeaconBlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = CheckpointV2FromVTPool() + } + if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Target == nil { + m.Target = CheckpointV2FromVTPool() + } + if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AggregateAttestationAndProof) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AggregateAttestationAndProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AggregateAttestationAndProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregatorIndex", wireType) + } + m.AggregatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AggregatorIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SelectionProof", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SelectionProof = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Aggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Aggregate == nil { + m.Aggregate = AttestationFromVTPool() + } + if err := m.Aggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedAggregateAttestationAndProof) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedAggregateAttestationAndProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedAggregateAttestationAndProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = AggregateAttestationAndProofFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AggregateAttestationAndProofV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AggregateAttestationAndProofV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AggregateAttestationAndProofV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AggregatorIndex == nil { + m.AggregatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.AggregatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Aggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Aggregate == nil { + m.Aggregate = AttestationV2FromVTPool() + } + if err := m.Aggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedAggregateAttestationAndProofV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedAggregateAttestationAndProofV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedAggregateAttestationAndProofV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = AggregateAttestationAndProofV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ElaboratedAttestation) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ElaboratedAttestation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ElaboratedAttestation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = AttestationDataV2FromVTPool() + } + if err := m.Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndexes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ValidatorIndexes) == cap(m.ValidatorIndexes) { + m.ValidatorIndexes = append(m.ValidatorIndexes, &wrapperspb1.UInt64Value{}) + } else { + m.ValidatorIndexes = m.ValidatorIndexes[:len(m.ValidatorIndexes)+1] + if m.ValidatorIndexes[len(m.ValidatorIndexes)-1] == nil { + m.ValidatorIndexes[len(m.ValidatorIndexes)-1] = &wrapperspb1.UInt64Value{} + } + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorIndexes[len(m.ValidatorIndexes)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/beacon_block_vtproto.pb.go b/pkg/proto/eth/v1/beacon_block_vtproto.pb.go new file mode 100644 index 000000000..d261c187f --- /dev/null +++ b/pkg/proto/eth/v1/beacon_block_vtproto.pb.go @@ -0,0 +1,6411 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/beacon_block.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *BeaconBlock) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProposerIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlock) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBody) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBody) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBody) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposerSlashing) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProposerSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProposerSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SignedHeader_2 != nil { + size, err := m.SignedHeader_2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.SignedHeader_1 != nil { + size, err := m.SignedHeader_1.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ProposerSlashingV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProposerSlashingV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProposerSlashingV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SignedHeader_2 != nil { + size, err := m.SignedHeader_2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.SignedHeader_1 != nil { + size, err := m.SignedHeader_1.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AttesterSlashing) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AttesterSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AttesterSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Attestation_2 != nil { + size, err := m.Attestation_2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Attestation_1 != nil { + size, err := m.Attestation_1.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AttesterSlashingV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AttesterSlashingV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AttesterSlashingV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Attestation_2 != nil { + size, err := m.Attestation_2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Attestation_1 != nil { + size, err := m.Attestation_1.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Deposit_Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Deposit_Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Deposit_Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 + } + if m.Amount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Amount)) + i-- + dAtA[i] = 0x18 + } + if len(m.WithdrawalCredentials) > 0 { + i -= len(m.WithdrawalCredentials) + copy(dAtA[i:], m.WithdrawalCredentials) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.WithdrawalCredentials))) + i-- + dAtA[i] = 0x12 + } + if len(m.Pubkey) > 0 { + i -= len(m.Pubkey) + copy(dAtA[i:], m.Pubkey) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Pubkey))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Deposit) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Deposit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Deposit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Data != nil { + size, err := m.Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.Proof) > 0 { + for iNdEx := len(m.Proof) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Proof[iNdEx]) + copy(dAtA[i:], m.Proof[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Proof[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *DepositV2_Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DepositV2_Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DepositV2_Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 + } + if m.Amount != nil { + size, err := (*wrapperspb.UInt64Value)(m.Amount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if len(m.WithdrawalCredentials) > 0 { + i -= len(m.WithdrawalCredentials) + copy(dAtA[i:], m.WithdrawalCredentials) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.WithdrawalCredentials))) + i-- + dAtA[i] = 0x12 + } + if len(m.Pubkey) > 0 { + i -= len(m.Pubkey) + copy(dAtA[i:], m.Pubkey) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Pubkey))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DepositV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DepositV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DepositV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Data != nil { + size, err := m.Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.Proof) > 0 { + for iNdEx := len(m.Proof) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Proof[iNdEx]) + copy(dAtA[i:], m.Proof[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Proof[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *VoluntaryExit) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *VoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *VoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ValidatorIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ValidatorIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Epoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Epoch)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *VoluntaryExitV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *VoluntaryExitV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *VoluntaryExitV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ValidatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.Epoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedVoluntaryExit) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedVoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedVoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedVoluntaryExitV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedVoluntaryExitV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedVoluntaryExitV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Eth1Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Eth1Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Eth1Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x1a + } + if m.DepositCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DepositCount)) + i-- + dAtA[i] = 0x10 + } + if len(m.DepositRoot) > 0 { + i -= len(m.DepositRoot) + copy(dAtA[i:], m.DepositRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DepositRoot))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockHeader) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockHeader) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockHeader) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BodyRoot) > 0 { + i -= len(m.BodyRoot) + copy(dAtA[i:], m.BodyRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BodyRoot))) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProposerIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockHeaderV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockHeaderV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockHeaderV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BodyRoot) > 0 { + i -= len(m.BodyRoot) + copy(dAtA[i:], m.BodyRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BodyRoot))) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockHeader) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockHeader) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockHeader) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockHeaderV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockHeaderV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockHeaderV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *IndexedAttestation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IndexedAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *IndexedAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x1a + } + if m.Data != nil { + size, err := m.Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.AttestingIndices) > 0 { + var pksize2 int + for _, num := range m.AttestingIndices { + pksize2 += protohelpers.SizeOfVarint(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range m.AttestingIndices { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *IndexedAttestationV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IndexedAttestationV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *IndexedAttestationV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x1a + } + if m.Data != nil { + size, err := m.Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.AttestingIndices) > 0 { + for iNdEx := len(m.AttestingIndices) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.UInt64Value)(m.AttestingIndices[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *SyncAggregate) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncAggregate) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SyncAggregate) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.SyncCommitteeSignature) > 0 { + i -= len(m.SyncCommitteeSignature) + copy(dAtA[i:], m.SyncCommitteeSignature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SyncCommitteeSignature))) + i-- + dAtA[i] = 0x12 + } + if len(m.SyncCommitteeBits) > 0 { + i -= len(m.SyncCommitteeBits) + copy(dAtA[i:], m.SyncCommitteeBits) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SyncCommitteeBits))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_BeaconBlock = sync.Pool{ + New: func() interface{} { + return &BeaconBlock{} + }, +} + +func (m *BeaconBlock) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlock) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlock.Put(m) + } +} +func BeaconBlockFromVTPool() *BeaconBlock { + return vtprotoPool_BeaconBlock.Get().(*BeaconBlock) +} + +var vtprotoPool_BeaconBlockV2 = sync.Pool{ + New: func() interface{} { + return &BeaconBlockV2{} + }, +} + +func (m *BeaconBlockV2) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockV2.Put(m) + } +} +func BeaconBlockV2FromVTPool() *BeaconBlockV2 { + return vtprotoPool_BeaconBlockV2.Get().(*BeaconBlockV2) +} + +var vtprotoPool_SignedBeaconBlock = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlock{} + }, +} + +func (m *SignedBeaconBlock) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlock) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlock.Put(m) + } +} +func SignedBeaconBlockFromVTPool() *SignedBeaconBlock { + return vtprotoPool_SignedBeaconBlock.Get().(*SignedBeaconBlock) +} + +var vtprotoPool_SignedBeaconBlockV2 = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockV2{} + }, +} + +func (m *SignedBeaconBlockV2) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockV2.Put(m) + } +} +func SignedBeaconBlockV2FromVTPool() *SignedBeaconBlockV2 { + return vtprotoPool_SignedBeaconBlockV2.Get().(*SignedBeaconBlockV2) +} + +var vtprotoPool_BeaconBlockBody = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBody{} + }, +} + +func (m *BeaconBlockBody) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + } +} +func (m *BeaconBlockBody) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBody.Put(m) + } +} +func BeaconBlockBodyFromVTPool() *BeaconBlockBody { + return vtprotoPool_BeaconBlockBody.Get().(*BeaconBlockBody) +} + +var vtprotoPool_ProposerSlashing = sync.Pool{ + New: func() interface{} { + return &ProposerSlashing{} + }, +} + +func (m *ProposerSlashing) ResetVT() { + if m != nil { + m.SignedHeader_1.ReturnToVTPool() + m.SignedHeader_2.ReturnToVTPool() + m.Reset() + } +} +func (m *ProposerSlashing) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ProposerSlashing.Put(m) + } +} +func ProposerSlashingFromVTPool() *ProposerSlashing { + return vtprotoPool_ProposerSlashing.Get().(*ProposerSlashing) +} + +var vtprotoPool_ProposerSlashingV2 = sync.Pool{ + New: func() interface{} { + return &ProposerSlashingV2{} + }, +} + +func (m *ProposerSlashingV2) ResetVT() { + if m != nil { + m.SignedHeader_1.ReturnToVTPool() + m.SignedHeader_2.ReturnToVTPool() + m.Reset() + } +} +func (m *ProposerSlashingV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ProposerSlashingV2.Put(m) + } +} +func ProposerSlashingV2FromVTPool() *ProposerSlashingV2 { + return vtprotoPool_ProposerSlashingV2.Get().(*ProposerSlashingV2) +} + +var vtprotoPool_AttesterSlashing = sync.Pool{ + New: func() interface{} { + return &AttesterSlashing{} + }, +} + +func (m *AttesterSlashing) ResetVT() { + if m != nil { + m.Attestation_1.ReturnToVTPool() + m.Attestation_2.ReturnToVTPool() + m.Reset() + } +} +func (m *AttesterSlashing) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AttesterSlashing.Put(m) + } +} +func AttesterSlashingFromVTPool() *AttesterSlashing { + return vtprotoPool_AttesterSlashing.Get().(*AttesterSlashing) +} + +var vtprotoPool_AttesterSlashingV2 = sync.Pool{ + New: func() interface{} { + return &AttesterSlashingV2{} + }, +} + +func (m *AttesterSlashingV2) ResetVT() { + if m != nil { + m.Attestation_1.ReturnToVTPool() + m.Attestation_2.ReturnToVTPool() + m.Reset() + } +} +func (m *AttesterSlashingV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AttesterSlashingV2.Put(m) + } +} +func AttesterSlashingV2FromVTPool() *AttesterSlashingV2 { + return vtprotoPool_AttesterSlashingV2.Get().(*AttesterSlashingV2) +} + +var vtprotoPool_Deposit_Data = sync.Pool{ + New: func() interface{} { + return &Deposit_Data{} + }, +} + +func (m *Deposit_Data) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Deposit_Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Deposit_Data.Put(m) + } +} +func Deposit_DataFromVTPool() *Deposit_Data { + return vtprotoPool_Deposit_Data.Get().(*Deposit_Data) +} + +var vtprotoPool_Deposit = sync.Pool{ + New: func() interface{} { + return &Deposit{} + }, +} + +func (m *Deposit) ResetVT() { + if m != nil { + f0 := m.Proof[:0] + m.Data.ReturnToVTPool() + m.Reset() + m.Proof = f0 + } +} +func (m *Deposit) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Deposit.Put(m) + } +} +func DepositFromVTPool() *Deposit { + return vtprotoPool_Deposit.Get().(*Deposit) +} + +var vtprotoPool_DepositV2_Data = sync.Pool{ + New: func() interface{} { + return &DepositV2_Data{} + }, +} + +func (m *DepositV2_Data) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *DepositV2_Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DepositV2_Data.Put(m) + } +} +func DepositV2_DataFromVTPool() *DepositV2_Data { + return vtprotoPool_DepositV2_Data.Get().(*DepositV2_Data) +} + +var vtprotoPool_DepositV2 = sync.Pool{ + New: func() interface{} { + return &DepositV2{} + }, +} + +func (m *DepositV2) ResetVT() { + if m != nil { + f0 := m.Proof[:0] + m.Data.ReturnToVTPool() + m.Reset() + m.Proof = f0 + } +} +func (m *DepositV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DepositV2.Put(m) + } +} +func DepositV2FromVTPool() *DepositV2 { + return vtprotoPool_DepositV2.Get().(*DepositV2) +} + +var vtprotoPool_VoluntaryExit = sync.Pool{ + New: func() interface{} { + return &VoluntaryExit{} + }, +} + +func (m *VoluntaryExit) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *VoluntaryExit) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_VoluntaryExit.Put(m) + } +} +func VoluntaryExitFromVTPool() *VoluntaryExit { + return vtprotoPool_VoluntaryExit.Get().(*VoluntaryExit) +} + +var vtprotoPool_VoluntaryExitV2 = sync.Pool{ + New: func() interface{} { + return &VoluntaryExitV2{} + }, +} + +func (m *VoluntaryExitV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *VoluntaryExitV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_VoluntaryExitV2.Put(m) + } +} +func VoluntaryExitV2FromVTPool() *VoluntaryExitV2 { + return vtprotoPool_VoluntaryExitV2.Get().(*VoluntaryExitV2) +} + +var vtprotoPool_SignedVoluntaryExit = sync.Pool{ + New: func() interface{} { + return &SignedVoluntaryExit{} + }, +} + +func (m *SignedVoluntaryExit) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedVoluntaryExit) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedVoluntaryExit.Put(m) + } +} +func SignedVoluntaryExitFromVTPool() *SignedVoluntaryExit { + return vtprotoPool_SignedVoluntaryExit.Get().(*SignedVoluntaryExit) +} + +var vtprotoPool_SignedVoluntaryExitV2 = sync.Pool{ + New: func() interface{} { + return &SignedVoluntaryExitV2{} + }, +} + +func (m *SignedVoluntaryExitV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedVoluntaryExitV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedVoluntaryExitV2.Put(m) + } +} +func SignedVoluntaryExitV2FromVTPool() *SignedVoluntaryExitV2 { + return vtprotoPool_SignedVoluntaryExitV2.Get().(*SignedVoluntaryExitV2) +} + +var vtprotoPool_Eth1Data = sync.Pool{ + New: func() interface{} { + return &Eth1Data{} + }, +} + +func (m *Eth1Data) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Eth1Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Eth1Data.Put(m) + } +} +func Eth1DataFromVTPool() *Eth1Data { + return vtprotoPool_Eth1Data.Get().(*Eth1Data) +} + +var vtprotoPool_BeaconBlockHeader = sync.Pool{ + New: func() interface{} { + return &BeaconBlockHeader{} + }, +} + +func (m *BeaconBlockHeader) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BeaconBlockHeader) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockHeader.Put(m) + } +} +func BeaconBlockHeaderFromVTPool() *BeaconBlockHeader { + return vtprotoPool_BeaconBlockHeader.Get().(*BeaconBlockHeader) +} + +var vtprotoPool_BeaconBlockHeaderV2 = sync.Pool{ + New: func() interface{} { + return &BeaconBlockHeaderV2{} + }, +} + +func (m *BeaconBlockHeaderV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BeaconBlockHeaderV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockHeaderV2.Put(m) + } +} +func BeaconBlockHeaderV2FromVTPool() *BeaconBlockHeaderV2 { + return vtprotoPool_BeaconBlockHeaderV2.Get().(*BeaconBlockHeaderV2) +} + +var vtprotoPool_SignedBeaconBlockHeader = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockHeader{} + }, +} + +func (m *SignedBeaconBlockHeader) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockHeader) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockHeader.Put(m) + } +} +func SignedBeaconBlockHeaderFromVTPool() *SignedBeaconBlockHeader { + return vtprotoPool_SignedBeaconBlockHeader.Get().(*SignedBeaconBlockHeader) +} + +var vtprotoPool_SignedBeaconBlockHeaderV2 = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockHeaderV2{} + }, +} + +func (m *SignedBeaconBlockHeaderV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockHeaderV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockHeaderV2.Put(m) + } +} +func SignedBeaconBlockHeaderV2FromVTPool() *SignedBeaconBlockHeaderV2 { + return vtprotoPool_SignedBeaconBlockHeaderV2.Get().(*SignedBeaconBlockHeaderV2) +} + +var vtprotoPool_IndexedAttestation = sync.Pool{ + New: func() interface{} { + return &IndexedAttestation{} + }, +} + +func (m *IndexedAttestation) ResetVT() { + if m != nil { + f0 := m.AttestingIndices[:0] + m.Data.ReturnToVTPool() + m.Reset() + m.AttestingIndices = f0 + } +} +func (m *IndexedAttestation) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_IndexedAttestation.Put(m) + } +} +func IndexedAttestationFromVTPool() *IndexedAttestation { + return vtprotoPool_IndexedAttestation.Get().(*IndexedAttestation) +} + +var vtprotoPool_IndexedAttestationV2 = sync.Pool{ + New: func() interface{} { + return &IndexedAttestationV2{} + }, +} + +func (m *IndexedAttestationV2) ResetVT() { + if m != nil { + for _, mm := range m.AttestingIndices { + mm.Reset() + } + f0 := m.AttestingIndices[:0] + m.Data.ReturnToVTPool() + m.Reset() + m.AttestingIndices = f0 + } +} +func (m *IndexedAttestationV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_IndexedAttestationV2.Put(m) + } +} +func IndexedAttestationV2FromVTPool() *IndexedAttestationV2 { + return vtprotoPool_IndexedAttestationV2.Get().(*IndexedAttestationV2) +} + +var vtprotoPool_SyncAggregate = sync.Pool{ + New: func() interface{} { + return &SyncAggregate{} + }, +} + +func (m *SyncAggregate) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *SyncAggregate) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SyncAggregate.Put(m) + } +} +func SyncAggregateFromVTPool() *SyncAggregate { + return vtprotoPool_SyncAggregate.Get().(*SyncAggregate) +} +func (m *BeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.ProposerIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProposerIndex)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBody) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ProposerSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SignedHeader_1 != nil { + l = m.SignedHeader_1.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SignedHeader_2 != nil { + l = m.SignedHeader_2.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ProposerSlashingV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SignedHeader_1 != nil { + l = m.SignedHeader_1.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SignedHeader_2 != nil { + l = m.SignedHeader_2.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AttesterSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Attestation_1 != nil { + l = m.Attestation_1.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Attestation_2 != nil { + l = m.Attestation_2.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AttesterSlashingV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Attestation_1 != nil { + l = m.Attestation_1.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Attestation_2 != nil { + l = m.Attestation_2.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Deposit_Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Pubkey) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.WithdrawalCredentials) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Amount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Amount)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Deposit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Proof) > 0 { + for _, s := range m.Proof { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Data != nil { + l = m.Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DepositV2_Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Pubkey) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.WithdrawalCredentials) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Amount != nil { + l = (*wrapperspb.UInt64Value)(m.Amount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DepositV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Proof) > 0 { + for _, s := range m.Proof { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Data != nil { + l = m.Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *VoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Epoch)) + } + if m.ValidatorIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ValidatorIndex)) + } + n += len(m.unknownFields) + return n +} + +func (m *VoluntaryExitV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = (*wrapperspb.UInt64Value)(m.Epoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ValidatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ValidatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedVoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedVoluntaryExitV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Eth1Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DepositRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DepositCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.DepositCount)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockHeader) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.ProposerIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProposerIndex)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BodyRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockHeaderV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BodyRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockHeader) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockHeaderV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *IndexedAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AttestingIndices) > 0 { + l = 0 + for _, e := range m.AttestingIndices { + l += protohelpers.SizeOfVarint(uint64(e)) + } + n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l + } + if m.Data != nil { + l = m.Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *IndexedAttestationV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AttestingIndices) > 0 { + for _, e := range m.AttestingIndices { + l = (*wrapperspb.UInt64Value)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Data != nil { + l = m.Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SyncAggregate) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SyncCommitteeBits) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SyncCommitteeSignature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlock) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + m.ProposerIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposerIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlock) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BeaconBlockFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BeaconBlockV2FromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBody) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBody: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBody: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposerSlashing) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ProposerSlashing: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposerSlashing: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SignedHeader_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SignedHeader_1 == nil { + m.SignedHeader_1 = SignedBeaconBlockHeaderFromVTPool() + } + if err := m.SignedHeader_1.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SignedHeader_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SignedHeader_2 == nil { + m.SignedHeader_2 = SignedBeaconBlockHeaderFromVTPool() + } + if err := m.SignedHeader_2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProposerSlashingV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ProposerSlashingV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposerSlashingV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SignedHeader_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SignedHeader_1 == nil { + m.SignedHeader_1 = SignedBeaconBlockHeaderV2FromVTPool() + } + if err := m.SignedHeader_1.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SignedHeader_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SignedHeader_2 == nil { + m.SignedHeader_2 = SignedBeaconBlockHeaderV2FromVTPool() + } + if err := m.SignedHeader_2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AttesterSlashing) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AttesterSlashing: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AttesterSlashing: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestation_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Attestation_1 == nil { + m.Attestation_1 = IndexedAttestationFromVTPool() + } + if err := m.Attestation_1.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestation_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Attestation_2 == nil { + m.Attestation_2 = IndexedAttestationFromVTPool() + } + if err := m.Attestation_2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AttesterSlashingV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AttesterSlashingV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AttesterSlashingV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestation_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Attestation_1 == nil { + m.Attestation_1 = IndexedAttestationV2FromVTPool() + } + if err := m.Attestation_1.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestation_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Attestation_2 == nil { + m.Attestation_2 = IndexedAttestationV2FromVTPool() + } + if err := m.Attestation_2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Deposit_Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Deposit_Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Deposit_Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Pubkey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawalCredentials", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithdrawalCredentials = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + m.Amount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Amount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Deposit) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Deposit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Deposit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proof = append(m.Proof, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = Deposit_DataFromVTPool() + } + if err := m.Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DepositV2_Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DepositV2_Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DepositV2_Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Pubkey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawalCredentials", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithdrawalCredentials = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Amount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DepositV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DepositV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DepositV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proof = append(m.Proof, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = DepositV2_DataFromVTPool() + } + if err := m.Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *VoluntaryExit) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: VoluntaryExit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VoluntaryExit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + m.Epoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Epoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + m.ValidatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *VoluntaryExitV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: VoluntaryExitV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VoluntaryExitV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Epoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorIndex == nil { + m.ValidatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedVoluntaryExit) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedVoluntaryExit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedVoluntaryExit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = VoluntaryExitFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedVoluntaryExitV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedVoluntaryExitV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedVoluntaryExitV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = VoluntaryExitV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Eth1Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Eth1Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Eth1Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DepositRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DepositRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DepositCount", wireType) + } + m.DepositCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DepositCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockHeader) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + m.ProposerIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposerIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BodyRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BodyRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockHeaderV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockHeaderV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockHeaderV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BodyRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BodyRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockHeader) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockHeaderFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockHeaderV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockHeaderV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockHeaderV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockHeaderV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IndexedAttestation) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IndexedAttestation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IndexedAttestation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AttestingIndices = append(m.AttestingIndices, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.AttestingIndices) == 0 && cap(m.AttestingIndices) < elementCount { + m.AttestingIndices = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AttestingIndices = append(m.AttestingIndices, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field AttestingIndices", wireType) + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = AttestationDataFromVTPool() + } + if err := m.Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IndexedAttestationV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IndexedAttestationV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IndexedAttestationV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttestingIndices", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttestingIndices) == cap(m.AttestingIndices) { + m.AttestingIndices = append(m.AttestingIndices, &wrapperspb1.UInt64Value{}) + } else { + m.AttestingIndices = m.AttestingIndices[:len(m.AttestingIndices)+1] + if m.AttestingIndices[len(m.AttestingIndices)-1] == nil { + m.AttestingIndices[len(m.AttestingIndices)-1] = &wrapperspb1.UInt64Value{} + } + } + if err := (*wrapperspb.UInt64Value)(m.AttestingIndices[len(m.AttestingIndices)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = AttestationDataV2FromVTPool() + } + if err := m.Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyncAggregate) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyncAggregate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncAggregate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncCommitteeBits", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SyncCommitteeBits = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncCommitteeSignature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SyncCommitteeSignature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/blob_vtproto.pb.go b/pkg/proto/eth/v1/blob_vtproto.pb.go new file mode 100644 index 000000000..3d2267713 --- /dev/null +++ b/pkg/proto/eth/v1/blob_vtproto.pb.go @@ -0,0 +1,939 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/blob.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *BlobSidecar) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.BlockParentRoot) > 0 { + i -= len(m.BlockParentRoot) + copy(dAtA[i:], m.BlockParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockParentRoot))) + i-- + dAtA[i] = 0x32 + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x2a + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.KzgProof) > 0 { + i -= len(m.KzgProof) + copy(dAtA[i:], m.KzgProof) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.KzgProof))) + i-- + dAtA[i] = 0x1a + } + if len(m.KzgCommitment) > 0 { + i -= len(m.KzgCommitment) + copy(dAtA[i:], m.KzgCommitment) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.KzgCommitment))) + i-- + dAtA[i] = 0x12 + } + if len(m.Blob) > 0 { + i -= len(m.Blob) + copy(dAtA[i:], m.Blob) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Blob))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Blob) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Blob) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Blob) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.VersionedHash) > 0 { + i -= len(m.VersionedHash) + copy(dAtA[i:], m.VersionedHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VersionedHash))) + i-- + dAtA[i] = 0x3a + } + if len(m.KzgCommitment) > 0 { + i -= len(m.KzgCommitment) + copy(dAtA[i:], m.KzgCommitment) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.KzgCommitment))) + i-- + dAtA[i] = 0x32 + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.BlockParentRoot) > 0 { + i -= len(m.BlockParentRoot) + copy(dAtA[i:], m.BlockParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockParentRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x1a + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_BlobSidecar = sync.Pool{ + New: func() interface{} { + return &BlobSidecar{} + }, +} + +func (m *BlobSidecar) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BlobSidecar) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlobSidecar.Put(m) + } +} +func BlobSidecarFromVTPool() *BlobSidecar { + return vtprotoPool_BlobSidecar.Get().(*BlobSidecar) +} + +var vtprotoPool_Blob = sync.Pool{ + New: func() interface{} { + return &Blob{} + }, +} + +func (m *Blob) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Blob) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Blob.Put(m) + } +} +func BlobFromVTPool() *Blob { + return vtprotoPool_Blob.Get().(*Blob) +} +func (m *BlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Blob) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.KzgCommitment) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.KzgProof) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Blob) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.KzgCommitment) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.VersionedHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlobSidecar) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlobSidecar: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlobSidecar: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Blob", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Blob = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KzgCommitment", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KzgCommitment = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KzgProof", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KzgProof = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Blob) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: 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 Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KzgCommitment", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KzgCommitment = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionedHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionedHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/checkpoint_vtproto.pb.go b/pkg/proto/eth/v1/checkpoint_vtproto.pb.go new file mode 100644 index 000000000..db6411f4c --- /dev/null +++ b/pkg/proto/eth/v1/checkpoint_vtproto.pb.go @@ -0,0 +1,415 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/checkpoint.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *Checkpoint) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Checkpoint) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Checkpoint) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Root) > 0 { + i -= len(m.Root) + copy(dAtA[i:], m.Root) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Root))) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Epoch)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *CheckpointV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CheckpointV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CheckpointV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Root) > 0 { + i -= len(m.Root) + copy(dAtA[i:], m.Root) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Root))) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.Epoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_Checkpoint = sync.Pool{ + New: func() interface{} { + return &Checkpoint{} + }, +} + +func (m *Checkpoint) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Checkpoint) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Checkpoint.Put(m) + } +} +func CheckpointFromVTPool() *Checkpoint { + return vtprotoPool_Checkpoint.Get().(*Checkpoint) +} + +var vtprotoPool_CheckpointV2 = sync.Pool{ + New: func() interface{} { + return &CheckpointV2{} + }, +} + +func (m *CheckpointV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *CheckpointV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CheckpointV2.Put(m) + } +} +func CheckpointV2FromVTPool() *CheckpointV2 { + return vtprotoPool_CheckpointV2.Get().(*CheckpointV2) +} +func (m *Checkpoint) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Epoch)) + } + l = len(m.Root) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CheckpointV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = (*wrapperspb.UInt64Value)(m.Epoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Root) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Checkpoint) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Checkpoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Checkpoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + m.Epoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Epoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Root = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CheckpointV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CheckpointV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CheckpointV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Epoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Root = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/committee_vtproto.pb.go b/pkg/proto/eth/v1/committee_vtproto.pb.go new file mode 100644 index 000000000..dc9ae78df --- /dev/null +++ b/pkg/proto/eth/v1/committee_vtproto.pb.go @@ -0,0 +1,301 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/committee.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *Committee) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Committee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Committee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Validators) > 0 { + for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.UInt64Value)(m.Validators[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_Committee = sync.Pool{ + New: func() interface{} { + return &Committee{} + }, +} + +func (m *Committee) ResetVT() { + if m != nil { + for _, mm := range m.Validators { + mm.Reset() + } + f0 := m.Validators[:0] + m.Reset() + m.Validators = f0 + } +} +func (m *Committee) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Committee.Put(m) + } +} +func CommitteeFromVTPool() *Committee { + return vtprotoPool_Committee.Get().(*Committee) +} +func (m *Committee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Validators) > 0 { + for _, e := range m.Validators { + l = (*wrapperspb.UInt64Value)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *Committee) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Committee: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Committee: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Validators) == cap(m.Validators) { + m.Validators = append(m.Validators, &wrapperspb1.UInt64Value{}) + } else { + m.Validators = m.Validators[:len(m.Validators)+1] + if m.Validators[len(m.Validators)-1] == nil { + m.Validators[len(m.Validators)-1] = &wrapperspb1.UInt64Value{} + } + } + if err := (*wrapperspb.UInt64Value)(m.Validators[len(m.Validators)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/duties_vtproto.pb.go b/pkg/proto/eth/v1/duties_vtproto.pb.go new file mode 100644 index 000000000..d5313169e --- /dev/null +++ b/pkg/proto/eth/v1/duties_vtproto.pb.go @@ -0,0 +1,280 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/duties.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *ProposerDuty) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProposerDuty) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProposerDuty) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Pubkey) > 0 { + i -= len(m.Pubkey) + copy(dAtA[i:], m.Pubkey) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Pubkey))) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.ValidatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_ProposerDuty = sync.Pool{ + New: func() interface{} { + return &ProposerDuty{} + }, +} + +func (m *ProposerDuty) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ProposerDuty) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ProposerDuty.Put(m) + } +} +func ProposerDutyFromVTPool() *ProposerDuty { + return vtprotoPool_ProposerDuty.Get().(*ProposerDuty) +} +func (m *ProposerDuty) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ValidatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Pubkey) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ProposerDuty) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ProposerDuty: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposerDuty: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorIndex == nil { + m.ValidatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Pubkey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/events_vtproto.pb.go b/pkg/proto/eth/v1/events_vtproto.pb.go new file mode 100644 index 000000000..12b19f18f --- /dev/null +++ b/pkg/proto/eth/v1/events_vtproto.pb.go @@ -0,0 +1,5160 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/events.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *EventHead) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventHead) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventHead) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.CurrentDutyDependentRoot) > 0 { + i -= len(m.CurrentDutyDependentRoot) + copy(dAtA[i:], m.CurrentDutyDependentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CurrentDutyDependentRoot))) + i-- + dAtA[i] = 0x32 + } + if len(m.PreviousDutyDependentRoot) > 0 { + i -= len(m.PreviousDutyDependentRoot) + copy(dAtA[i:], m.PreviousDutyDependentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PreviousDutyDependentRoot))) + i-- + dAtA[i] = 0x2a + } + if m.EpochTransition { + i-- + if m.EpochTransition { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0x1a + } + if len(m.Block) > 0 { + i -= len(m.Block) + copy(dAtA[i:], m.Block) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Block))) + i-- + dAtA[i] = 0x12 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EventHeadV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventHeadV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventHeadV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.CurrentDutyDependentRoot) > 0 { + i -= len(m.CurrentDutyDependentRoot) + copy(dAtA[i:], m.CurrentDutyDependentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CurrentDutyDependentRoot))) + i-- + dAtA[i] = 0x32 + } + if len(m.PreviousDutyDependentRoot) > 0 { + i -= len(m.PreviousDutyDependentRoot) + copy(dAtA[i:], m.PreviousDutyDependentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PreviousDutyDependentRoot))) + i-- + dAtA[i] = 0x2a + } + if m.EpochTransition { + i-- + if m.EpochTransition { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0x1a + } + if len(m.Block) > 0 { + i -= len(m.Block) + copy(dAtA[i:], m.Block) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Block))) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventBlock) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExecutionOptimistic { + i-- + if m.ExecutionOptimistic { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Block) > 0 { + i -= len(m.Block) + copy(dAtA[i:], m.Block) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Block))) + i-- + dAtA[i] = 0x12 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EventBlockV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventBlockV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExecutionOptimistic { + i-- + if m.ExecutionOptimistic { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Block) > 0 { + i -= len(m.Block) + copy(dAtA[i:], m.Block) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Block))) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventChainReorg) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventChainReorg) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventChainReorg) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Epoch)) + i-- + dAtA[i] = 0x38 + } + if len(m.NewHeadState) > 0 { + i -= len(m.NewHeadState) + copy(dAtA[i:], m.NewHeadState) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewHeadState))) + i-- + dAtA[i] = 0x32 + } + if len(m.OldHeadState) > 0 { + i -= len(m.OldHeadState) + copy(dAtA[i:], m.OldHeadState) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldHeadState))) + i-- + dAtA[i] = 0x2a + } + if len(m.NewHeadBlock) > 0 { + i -= len(m.NewHeadBlock) + copy(dAtA[i:], m.NewHeadBlock) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewHeadBlock))) + i-- + dAtA[i] = 0x22 + } + if len(m.OldHeadBlock) > 0 { + i -= len(m.OldHeadBlock) + copy(dAtA[i:], m.OldHeadBlock) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldHeadBlock))) + i-- + dAtA[i] = 0x1a + } + if m.Depth != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Depth)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EventChainReorgV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventChainReorgV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventChainReorgV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.Epoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.NewHeadState) > 0 { + i -= len(m.NewHeadState) + copy(dAtA[i:], m.NewHeadState) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewHeadState))) + i-- + dAtA[i] = 0x32 + } + if len(m.OldHeadState) > 0 { + i -= len(m.OldHeadState) + copy(dAtA[i:], m.OldHeadState) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldHeadState))) + i-- + dAtA[i] = 0x2a + } + if len(m.NewHeadBlock) > 0 { + i -= len(m.NewHeadBlock) + copy(dAtA[i:], m.NewHeadBlock) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewHeadBlock))) + i-- + dAtA[i] = 0x22 + } + if len(m.OldHeadBlock) > 0 { + i -= len(m.OldHeadBlock) + copy(dAtA[i:], m.OldHeadBlock) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldHeadBlock))) + i-- + dAtA[i] = 0x1a + } + if m.Depth != nil { + size, err := (*wrapperspb.UInt64Value)(m.Depth).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventFinalizedCheckpoint) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventFinalizedCheckpoint) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventFinalizedCheckpoint) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Epoch)) + i-- + dAtA[i] = 0x18 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0x12 + } + if len(m.Block) > 0 { + i -= len(m.Block) + copy(dAtA[i:], m.Block) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Block))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventFinalizedCheckpointV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventFinalizedCheckpointV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventFinalizedCheckpointV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.Epoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0x12 + } + if len(m.Block) > 0 { + i -= len(m.Block) + copy(dAtA[i:], m.Block) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Block))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventVoluntaryExitMessage) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventVoluntaryExitMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventVoluntaryExitMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ValidatorIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ValidatorIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Epoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Epoch)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EventVoluntaryExitMessageV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventVoluntaryExitMessageV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventVoluntaryExitMessageV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ValidatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.Epoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventVoluntaryExit) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventVoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventVoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.ValidatorIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ValidatorIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Epoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Epoch)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EventVoluntaryExitV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventVoluntaryExitV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventVoluntaryExitV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} + +func (m *ContributionAndProof) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContributionAndProof) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ContributionAndProof) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.SelectionProof) > 0 { + i -= len(m.SelectionProof) + copy(dAtA[i:], m.SelectionProof) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SelectionProof))) + i-- + dAtA[i] = 0x1a + } + if m.Contribution != nil { + size, err := m.Contribution.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.AggregatorIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.AggregatorIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ContributionAndProofV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContributionAndProofV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ContributionAndProofV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.SelectionProof) > 0 { + i -= len(m.SelectionProof) + copy(dAtA[i:], m.SelectionProof) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SelectionProof))) + i-- + dAtA[i] = 0x1a + } + if m.Contribution != nil { + size, err := m.Contribution.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.AggregatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.AggregatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventContributionAndProof) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventContributionAndProof) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventContributionAndProof) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventContributionAndProofV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventContributionAndProofV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventContributionAndProofV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventBlobSidecar) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.VersionedHash) > 0 { + i -= len(m.VersionedHash) + copy(dAtA[i:], m.VersionedHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VersionedHash))) + i-- + dAtA[i] = 0x2a + } + if len(m.KzgCommitment) > 0 { + i -= len(m.KzgCommitment) + copy(dAtA[i:], m.KzgCommitment) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.KzgCommitment))) + i-- + dAtA[i] = 0x22 + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventBlockGossip) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventBlockGossip) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockGossip) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Block) > 0 { + i -= len(m.Block) + copy(dAtA[i:], m.Block) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Block))) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventDataColumnSidecar) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventDataColumnSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventDataColumnSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.KzgCommitmentsCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.KzgCommitmentsCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.KzgCommitments) > 0 { + for iNdEx := len(m.KzgCommitments) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.KzgCommitments[iNdEx]) + copy(dAtA[i:], m.KzgCommitments[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.KzgCommitments[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x1a + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_EventHead = sync.Pool{ + New: func() interface{} { + return &EventHead{} + }, +} + +func (m *EventHead) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventHead) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventHead.Put(m) + } +} +func EventHeadFromVTPool() *EventHead { + return vtprotoPool_EventHead.Get().(*EventHead) +} + +var vtprotoPool_EventHeadV2 = sync.Pool{ + New: func() interface{} { + return &EventHeadV2{} + }, +} + +func (m *EventHeadV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventHeadV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventHeadV2.Put(m) + } +} +func EventHeadV2FromVTPool() *EventHeadV2 { + return vtprotoPool_EventHeadV2.Get().(*EventHeadV2) +} + +var vtprotoPool_EventBlock = sync.Pool{ + New: func() interface{} { + return &EventBlock{} + }, +} + +func (m *EventBlock) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventBlock) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventBlock.Put(m) + } +} +func EventBlockFromVTPool() *EventBlock { + return vtprotoPool_EventBlock.Get().(*EventBlock) +} + +var vtprotoPool_EventBlockV2 = sync.Pool{ + New: func() interface{} { + return &EventBlockV2{} + }, +} + +func (m *EventBlockV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventBlockV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventBlockV2.Put(m) + } +} +func EventBlockV2FromVTPool() *EventBlockV2 { + return vtprotoPool_EventBlockV2.Get().(*EventBlockV2) +} + +var vtprotoPool_EventChainReorg = sync.Pool{ + New: func() interface{} { + return &EventChainReorg{} + }, +} + +func (m *EventChainReorg) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventChainReorg) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventChainReorg.Put(m) + } +} +func EventChainReorgFromVTPool() *EventChainReorg { + return vtprotoPool_EventChainReorg.Get().(*EventChainReorg) +} + +var vtprotoPool_EventChainReorgV2 = sync.Pool{ + New: func() interface{} { + return &EventChainReorgV2{} + }, +} + +func (m *EventChainReorgV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventChainReorgV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventChainReorgV2.Put(m) + } +} +func EventChainReorgV2FromVTPool() *EventChainReorgV2 { + return vtprotoPool_EventChainReorgV2.Get().(*EventChainReorgV2) +} + +var vtprotoPool_EventFinalizedCheckpoint = sync.Pool{ + New: func() interface{} { + return &EventFinalizedCheckpoint{} + }, +} + +func (m *EventFinalizedCheckpoint) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventFinalizedCheckpoint) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventFinalizedCheckpoint.Put(m) + } +} +func EventFinalizedCheckpointFromVTPool() *EventFinalizedCheckpoint { + return vtprotoPool_EventFinalizedCheckpoint.Get().(*EventFinalizedCheckpoint) +} + +var vtprotoPool_EventFinalizedCheckpointV2 = sync.Pool{ + New: func() interface{} { + return &EventFinalizedCheckpointV2{} + }, +} + +func (m *EventFinalizedCheckpointV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventFinalizedCheckpointV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventFinalizedCheckpointV2.Put(m) + } +} +func EventFinalizedCheckpointV2FromVTPool() *EventFinalizedCheckpointV2 { + return vtprotoPool_EventFinalizedCheckpointV2.Get().(*EventFinalizedCheckpointV2) +} + +var vtprotoPool_EventVoluntaryExitMessage = sync.Pool{ + New: func() interface{} { + return &EventVoluntaryExitMessage{} + }, +} + +func (m *EventVoluntaryExitMessage) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventVoluntaryExitMessage) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventVoluntaryExitMessage.Put(m) + } +} +func EventVoluntaryExitMessageFromVTPool() *EventVoluntaryExitMessage { + return vtprotoPool_EventVoluntaryExitMessage.Get().(*EventVoluntaryExitMessage) +} + +var vtprotoPool_EventVoluntaryExitMessageV2 = sync.Pool{ + New: func() interface{} { + return &EventVoluntaryExitMessageV2{} + }, +} + +func (m *EventVoluntaryExitMessageV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventVoluntaryExitMessageV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventVoluntaryExitMessageV2.Put(m) + } +} +func EventVoluntaryExitMessageV2FromVTPool() *EventVoluntaryExitMessageV2 { + return vtprotoPool_EventVoluntaryExitMessageV2.Get().(*EventVoluntaryExitMessageV2) +} + +var vtprotoPool_EventVoluntaryExit = sync.Pool{ + New: func() interface{} { + return &EventVoluntaryExit{} + }, +} + +func (m *EventVoluntaryExit) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *EventVoluntaryExit) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventVoluntaryExit.Put(m) + } +} +func EventVoluntaryExitFromVTPool() *EventVoluntaryExit { + return vtprotoPool_EventVoluntaryExit.Get().(*EventVoluntaryExit) +} + +var vtprotoPool_EventVoluntaryExitV2 = sync.Pool{ + New: func() interface{} { + return &EventVoluntaryExitV2{} + }, +} + +func (m *EventVoluntaryExitV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *EventVoluntaryExitV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventVoluntaryExitV2.Put(m) + } +} +func EventVoluntaryExitV2FromVTPool() *EventVoluntaryExitV2 { + return vtprotoPool_EventVoluntaryExitV2.Get().(*EventVoluntaryExitV2) +} + +var vtprotoPool_ContributionAndProof = sync.Pool{ + New: func() interface{} { + return &ContributionAndProof{} + }, +} + +func (m *ContributionAndProof) ResetVT() { + if m != nil { + m.Contribution.ReturnToVTPool() + m.Reset() + } +} +func (m *ContributionAndProof) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ContributionAndProof.Put(m) + } +} +func ContributionAndProofFromVTPool() *ContributionAndProof { + return vtprotoPool_ContributionAndProof.Get().(*ContributionAndProof) +} + +var vtprotoPool_ContributionAndProofV2 = sync.Pool{ + New: func() interface{} { + return &ContributionAndProofV2{} + }, +} + +func (m *ContributionAndProofV2) ResetVT() { + if m != nil { + m.Contribution.ReturnToVTPool() + m.Reset() + } +} +func (m *ContributionAndProofV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ContributionAndProofV2.Put(m) + } +} +func ContributionAndProofV2FromVTPool() *ContributionAndProofV2 { + return vtprotoPool_ContributionAndProofV2.Get().(*ContributionAndProofV2) +} + +var vtprotoPool_EventContributionAndProof = sync.Pool{ + New: func() interface{} { + return &EventContributionAndProof{} + }, +} + +func (m *EventContributionAndProof) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *EventContributionAndProof) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventContributionAndProof.Put(m) + } +} +func EventContributionAndProofFromVTPool() *EventContributionAndProof { + return vtprotoPool_EventContributionAndProof.Get().(*EventContributionAndProof) +} + +var vtprotoPool_EventContributionAndProofV2 = sync.Pool{ + New: func() interface{} { + return &EventContributionAndProofV2{} + }, +} + +func (m *EventContributionAndProofV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *EventContributionAndProofV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventContributionAndProofV2.Put(m) + } +} +func EventContributionAndProofV2FromVTPool() *EventContributionAndProofV2 { + return vtprotoPool_EventContributionAndProofV2.Get().(*EventContributionAndProofV2) +} + +var vtprotoPool_EventBlobSidecar = sync.Pool{ + New: func() interface{} { + return &EventBlobSidecar{} + }, +} + +func (m *EventBlobSidecar) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventBlobSidecar) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventBlobSidecar.Put(m) + } +} +func EventBlobSidecarFromVTPool() *EventBlobSidecar { + return vtprotoPool_EventBlobSidecar.Get().(*EventBlobSidecar) +} + +var vtprotoPool_EventBlockGossip = sync.Pool{ + New: func() interface{} { + return &EventBlockGossip{} + }, +} + +func (m *EventBlockGossip) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EventBlockGossip) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventBlockGossip.Put(m) + } +} +func EventBlockGossipFromVTPool() *EventBlockGossip { + return vtprotoPool_EventBlockGossip.Get().(*EventBlockGossip) +} + +var vtprotoPool_EventDataColumnSidecar = sync.Pool{ + New: func() interface{} { + return &EventDataColumnSidecar{} + }, +} + +func (m *EventDataColumnSidecar) ResetVT() { + if m != nil { + f0 := m.KzgCommitments[:0] + m.Reset() + m.KzgCommitments = f0 + } +} +func (m *EventDataColumnSidecar) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventDataColumnSidecar.Put(m) + } +} +func EventDataColumnSidecarFromVTPool() *EventDataColumnSidecar { + return vtprotoPool_EventDataColumnSidecar.Get().(*EventDataColumnSidecar) +} +func (m *EventHead) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + l = len(m.Block) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.State) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.EpochTransition { + n += 2 + } + l = len(m.PreviousDutyDependentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.CurrentDutyDependentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventHeadV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Block) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.State) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.EpochTransition { + n += 2 + } + l = len(m.PreviousDutyDependentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.CurrentDutyDependentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + l = len(m.Block) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionOptimistic { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *EventBlockV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Block) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionOptimistic { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *EventChainReorg) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.Depth != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Depth)) + } + l = len(m.OldHeadBlock) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.NewHeadBlock) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.OldHeadState) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.NewHeadState) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Epoch)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventChainReorgV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Depth != nil { + l = (*wrapperspb.UInt64Value)(m.Depth).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.OldHeadBlock) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.NewHeadBlock) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.OldHeadState) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.NewHeadState) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = (*wrapperspb.UInt64Value)(m.Epoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventFinalizedCheckpoint) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Block) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.State) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Epoch)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventFinalizedCheckpointV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Block) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.State) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = (*wrapperspb.UInt64Value)(m.Epoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventVoluntaryExitMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Epoch)) + } + if m.ValidatorIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ValidatorIndex)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventVoluntaryExitMessageV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = (*wrapperspb.UInt64Value)(m.Epoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ValidatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ValidatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventVoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Epoch)) + } + if m.ValidatorIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ValidatorIndex)) + } + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventVoluntaryExitV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ContributionAndProof) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AggregatorIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.AggregatorIndex)) + } + if m.Contribution != nil { + l = m.Contribution.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SelectionProof) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ContributionAndProofV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AggregatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.AggregatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Contribution != nil { + l = m.Contribution.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SelectionProof) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventContributionAndProof) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventContributionAndProofV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.KzgCommitment) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.VersionedHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventBlockGossip) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Block) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventDataColumnSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.KzgCommitments) > 0 { + for _, s := range m.KzgCommitments { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.KzgCommitmentsCount != nil { + l = (*wrapperspb.UInt32Value)(m.KzgCommitmentsCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventHead) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventHead: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventHead: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Block = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochTransition", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EpochTransition = bool(v != 0) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviousDutyDependentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PreviousDutyDependentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentDutyDependentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CurrentDutyDependentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventHeadV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventHeadV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventHeadV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Block = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochTransition", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EpochTransition = bool(v != 0) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviousDutyDependentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PreviousDutyDependentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentDutyDependentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CurrentDutyDependentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventBlock) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Block = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionOptimistic", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ExecutionOptimistic = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventBlockV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventBlockV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBlockV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Block = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionOptimistic", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ExecutionOptimistic = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventChainReorg) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventChainReorg: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventChainReorg: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Depth", wireType) + } + m.Depth = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Depth |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OldHeadBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OldHeadBlock = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewHeadBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewHeadBlock = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OldHeadState", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OldHeadState = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewHeadState", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewHeadState = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + m.Epoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Epoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventChainReorgV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventChainReorgV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventChainReorgV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Depth", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Depth == nil { + m.Depth = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Depth).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OldHeadBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OldHeadBlock = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewHeadBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewHeadBlock = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OldHeadState", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OldHeadState = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewHeadState", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewHeadState = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Epoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventFinalizedCheckpoint) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventFinalizedCheckpoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventFinalizedCheckpoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Block = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + m.Epoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Epoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventFinalizedCheckpointV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventFinalizedCheckpointV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventFinalizedCheckpointV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Block = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Epoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventVoluntaryExitMessage) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventVoluntaryExitMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventVoluntaryExitMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + m.Epoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Epoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + m.ValidatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventVoluntaryExitMessageV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventVoluntaryExitMessageV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventVoluntaryExitMessageV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Epoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorIndex == nil { + m.ValidatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventVoluntaryExit) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventVoluntaryExit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventVoluntaryExit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + m.Epoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Epoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + m.ValidatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = EventVoluntaryExitMessageFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventVoluntaryExitV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventVoluntaryExitV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventVoluntaryExitV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = EventVoluntaryExitMessageV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ContributionAndProof) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContributionAndProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContributionAndProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregatorIndex", wireType) + } + m.AggregatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AggregatorIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contribution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Contribution == nil { + m.Contribution = SyncCommitteeContributionFromVTPool() + } + if err := m.Contribution.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SelectionProof", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SelectionProof = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ContributionAndProofV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContributionAndProofV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContributionAndProofV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AggregatorIndex == nil { + m.AggregatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.AggregatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contribution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Contribution == nil { + m.Contribution = SyncCommitteeContributionV2FromVTPool() + } + if err := m.Contribution.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SelectionProof", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SelectionProof = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventContributionAndProof) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventContributionAndProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventContributionAndProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = ContributionAndProofFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventContributionAndProofV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventContributionAndProofV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventContributionAndProofV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = ContributionAndProofV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventBlobSidecar) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventBlobSidecar: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBlobSidecar: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KzgCommitment", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KzgCommitment = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionedHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionedHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventBlockGossip) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventBlockGossip: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBlockGossip: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Block = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventDataColumnSidecar) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventDataColumnSidecar: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventDataColumnSidecar: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KzgCommitments", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KzgCommitments = append(m.KzgCommitments, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KzgCommitmentsCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.KzgCommitmentsCount == nil { + m.KzgCommitmentsCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.KzgCommitmentsCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/execution_engine_vtproto.pb.go b/pkg/proto/eth/v1/execution_engine_vtproto.pb.go new file mode 100644 index 000000000..4a719ad59 --- /dev/null +++ b/pkg/proto/eth/v1/execution_engine_vtproto.pb.go @@ -0,0 +1,9950 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/execution_engine.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *ExecutionPayload) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayload) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayload) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Transactions) > 0 { + for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Transactions[iNdEx]) + copy(dAtA[i:], m.Transactions[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Transactions[iNdEx]))) + i-- + dAtA[i] = 0x72 + } + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Timestamp)) + i-- + dAtA[i] = 0x50 + } + if m.GasUsed != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GasUsed)) + i-- + dAtA[i] = 0x48 + } + if m.GasLimit != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GasLimit)) + i-- + dAtA[i] = 0x40 + } + if m.BlockNumber != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BlockNumber)) + i-- + dAtA[i] = 0x38 + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Transactions) > 0 { + for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Transactions[iNdEx]) + copy(dAtA[i:], m.Transactions[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Transactions[iNdEx]))) + i-- + dAtA[i] = 0x72 + } + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.UInt64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadHeader) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadHeader) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadHeader) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.TransactionsRoot) > 0 { + i -= len(m.TransactionsRoot) + copy(dAtA[i:], m.TransactionsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TransactionsRoot))) + i-- + dAtA[i] = 0x72 + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Timestamp)) + i-- + dAtA[i] = 0x50 + } + if m.GasUsed != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GasUsed)) + i-- + dAtA[i] = 0x48 + } + if m.GasLimit != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GasLimit)) + i-- + dAtA[i] = 0x40 + } + if m.BlockNumber != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BlockNumber)) + i-- + dAtA[i] = 0x38 + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadHeaderV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadHeaderV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadHeaderV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.TransactionsRoot) > 0 { + i -= len(m.TransactionsRoot) + copy(dAtA[i:], m.TransactionsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TransactionsRoot))) + i-- + dAtA[i] = 0x72 + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.UInt64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadCapella) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadCapella) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadCapella) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Withdrawals) > 0 { + for iNdEx := len(m.Withdrawals) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Withdrawals[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + } + if len(m.Transactions) > 0 { + for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Transactions[iNdEx]) + copy(dAtA[i:], m.Transactions[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Transactions[iNdEx]))) + i-- + dAtA[i] = 0x72 + } + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Timestamp)) + i-- + dAtA[i] = 0x50 + } + if m.GasUsed != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GasUsed)) + i-- + dAtA[i] = 0x48 + } + if m.GasLimit != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GasLimit)) + i-- + dAtA[i] = 0x40 + } + if m.BlockNumber != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BlockNumber)) + i-- + dAtA[i] = 0x38 + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadCapellaV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadCapellaV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadCapellaV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Withdrawals) > 0 { + for iNdEx := len(m.Withdrawals) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Withdrawals[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + } + if len(m.Transactions) > 0 { + for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Transactions[iNdEx]) + copy(dAtA[i:], m.Transactions[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Transactions[iNdEx]))) + i-- + dAtA[i] = 0x72 + } + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.UInt64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadDeneb) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadDeneb) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadDeneb) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExcessBlobGas != nil { + size, err := (*wrapperspb.UInt64Value)(m.ExcessBlobGas).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if m.BlobGasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlobGasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if len(m.Withdrawals) > 0 { + for iNdEx := len(m.Withdrawals) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Withdrawals[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + } + if len(m.Transactions) > 0 { + for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Transactions[iNdEx]) + copy(dAtA[i:], m.Transactions[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Transactions[iNdEx]))) + i-- + dAtA[i] = 0x72 + } + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.UInt64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadElectra) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadElectra) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadElectra) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExcessBlobGas != nil { + size, err := (*wrapperspb.UInt64Value)(m.ExcessBlobGas).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if m.BlobGasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlobGasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if len(m.Withdrawals) > 0 { + for iNdEx := len(m.Withdrawals) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Withdrawals[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + } + if len(m.Transactions) > 0 { + for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Transactions[iNdEx]) + copy(dAtA[i:], m.Transactions[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Transactions[iNdEx]))) + i-- + dAtA[i] = 0x72 + } + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.UInt64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadFulu) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadFulu) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadFulu) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExcessBlobGas != nil { + size, err := (*wrapperspb.UInt64Value)(m.ExcessBlobGas).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if m.BlobGasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlobGasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if len(m.Withdrawals) > 0 { + for iNdEx := len(m.Withdrawals) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Withdrawals[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + } + if len(m.Transactions) > 0 { + for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Transactions[iNdEx]) + copy(dAtA[i:], m.Transactions[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Transactions[iNdEx]))) + i-- + dAtA[i] = 0x72 + } + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.UInt64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Withdrawal) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Withdrawal) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Withdrawal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Amount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Amount)) + i-- + dAtA[i] = 0x20 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0x1a + } + if m.ValidatorIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ValidatorIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Index != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *WithdrawalV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WithdrawalV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *WithdrawalV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Amount != nil { + size, err := (*wrapperspb.UInt64Value)(m.Amount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0x1a + } + if m.ValidatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadHeaderCapella) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadHeaderCapella) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadHeaderCapella) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.WithdrawalsRoot) > 0 { + i -= len(m.WithdrawalsRoot) + copy(dAtA[i:], m.WithdrawalsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.WithdrawalsRoot))) + i-- + dAtA[i] = 0x7a + } + if len(m.TransactionsRoot) > 0 { + i -= len(m.TransactionsRoot) + copy(dAtA[i:], m.TransactionsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TransactionsRoot))) + i-- + dAtA[i] = 0x72 + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Timestamp)) + i-- + dAtA[i] = 0x50 + } + if m.GasUsed != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GasUsed)) + i-- + dAtA[i] = 0x48 + } + if m.GasLimit != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GasLimit)) + i-- + dAtA[i] = 0x40 + } + if m.BlockNumber != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BlockNumber)) + i-- + dAtA[i] = 0x38 + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionPayloadHeaderCapellaV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionPayloadHeaderCapellaV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionPayloadHeaderCapellaV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.WithdrawalsRoot) > 0 { + i -= len(m.WithdrawalsRoot) + copy(dAtA[i:], m.WithdrawalsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.WithdrawalsRoot))) + i-- + dAtA[i] = 0x7a + } + if len(m.TransactionsRoot) > 0 { + i -= len(m.TransactionsRoot) + copy(dAtA[i:], m.TransactionsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TransactionsRoot))) + i-- + dAtA[i] = 0x72 + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.BaseFeePerGas) > 0 { + i -= len(m.BaseFeePerGas) + copy(dAtA[i:], m.BaseFeePerGas) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BaseFeePerGas))) + i-- + dAtA[i] = 0x62 + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x5a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.UInt64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.PrevRandao) > 0 { + i -= len(m.PrevRandao) + copy(dAtA[i:], m.PrevRandao) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PrevRandao))) + i-- + dAtA[i] = 0x32 + } + if len(m.LogsBloom) > 0 { + i -= len(m.LogsBloom) + copy(dAtA[i:], m.LogsBloom) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LogsBloom))) + i-- + dAtA[i] = 0x2a + } + if len(m.ReceiptsRoot) > 0 { + i -= len(m.ReceiptsRoot) + copy(dAtA[i:], m.ReceiptsRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ReceiptsRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.FeeRecipient) > 0 { + i -= len(m.FeeRecipient) + copy(dAtA[i:], m.FeeRecipient) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FeeRecipient))) + i-- + dAtA[i] = 0x12 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Transaction) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Transaction) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Transaction) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlobHashes) > 0 { + for iNdEx := len(m.BlobHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.BlobHashes[iNdEx]) + copy(dAtA[i:], m.BlobHashes[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobHashes[iNdEx]))) + i-- + dAtA[i] = 0x7a + } + } + if len(m.BlobGasFeeCap) > 0 { + i -= len(m.BlobGasFeeCap) + copy(dAtA[i:], m.BlobGasFeeCap) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobGasFeeCap))) + i-- + dAtA[i] = 0x72 + } + if m.BlobGas != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlobGas).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if len(m.GasFeeCap) > 0 { + i -= len(m.GasFeeCap) + copy(dAtA[i:], m.GasFeeCap) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GasFeeCap))) + i-- + dAtA[i] = 0x62 + } + if len(m.GasTipCap) > 0 { + i -= len(m.GasTipCap) + copy(dAtA[i:], m.GasTipCap) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GasTipCap))) + i-- + dAtA[i] = 0x5a + } + if m.Type != nil { + size, err := (*wrapperspb.UInt32Value)(m.Type).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x4a + } + if m.Nonce != nil { + size, err := (*wrapperspb.UInt64Value)(m.Nonce).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if len(m.To) > 0 { + i -= len(m.To) + copy(dAtA[i:], m.To) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.To))) + i-- + dAtA[i] = 0x3a + } + if len(m.From) > 0 { + i -= len(m.From) + copy(dAtA[i:], m.From) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.From))) + i-- + dAtA[i] = 0x32 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0x2a + } + if len(m.GasPrice) > 0 { + i -= len(m.GasPrice) + copy(dAtA[i:], m.GasPrice) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GasPrice))) + i-- + dAtA[i] = 0x22 + } + if m.Gas != nil { + size, err := (*wrapperspb.UInt64Value)(m.Gas).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if len(m.Input) > 0 { + i -= len(m.Input) + copy(dAtA[i:], m.Input) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Input))) + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_ExecutionPayload = sync.Pool{ + New: func() interface{} { + return &ExecutionPayload{} + }, +} + +func (m *ExecutionPayload) ResetVT() { + if m != nil { + f0 := m.Transactions[:0] + m.Reset() + m.Transactions = f0 + } +} +func (m *ExecutionPayload) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayload.Put(m) + } +} +func ExecutionPayloadFromVTPool() *ExecutionPayload { + return vtprotoPool_ExecutionPayload.Get().(*ExecutionPayload) +} + +var vtprotoPool_ExecutionPayloadV2 = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadV2{} + }, +} + +func (m *ExecutionPayloadV2) ResetVT() { + if m != nil { + f0 := m.Transactions[:0] + m.Reset() + m.Transactions = f0 + } +} +func (m *ExecutionPayloadV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadV2.Put(m) + } +} +func ExecutionPayloadV2FromVTPool() *ExecutionPayloadV2 { + return vtprotoPool_ExecutionPayloadV2.Get().(*ExecutionPayloadV2) +} + +var vtprotoPool_ExecutionPayloadHeader = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadHeader{} + }, +} + +func (m *ExecutionPayloadHeader) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionPayloadHeader) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadHeader.Put(m) + } +} +func ExecutionPayloadHeaderFromVTPool() *ExecutionPayloadHeader { + return vtprotoPool_ExecutionPayloadHeader.Get().(*ExecutionPayloadHeader) +} + +var vtprotoPool_ExecutionPayloadHeaderV2 = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadHeaderV2{} + }, +} + +func (m *ExecutionPayloadHeaderV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionPayloadHeaderV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadHeaderV2.Put(m) + } +} +func ExecutionPayloadHeaderV2FromVTPool() *ExecutionPayloadHeaderV2 { + return vtprotoPool_ExecutionPayloadHeaderV2.Get().(*ExecutionPayloadHeaderV2) +} + +var vtprotoPool_ExecutionPayloadCapella = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadCapella{} + }, +} + +func (m *ExecutionPayloadCapella) ResetVT() { + if m != nil { + f0 := m.Transactions[:0] + for _, mm := range m.Withdrawals { + mm.ResetVT() + } + f1 := m.Withdrawals[:0] + m.Reset() + m.Transactions = f0 + m.Withdrawals = f1 + } +} +func (m *ExecutionPayloadCapella) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadCapella.Put(m) + } +} +func ExecutionPayloadCapellaFromVTPool() *ExecutionPayloadCapella { + return vtprotoPool_ExecutionPayloadCapella.Get().(*ExecutionPayloadCapella) +} + +var vtprotoPool_ExecutionPayloadCapellaV2 = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadCapellaV2{} + }, +} + +func (m *ExecutionPayloadCapellaV2) ResetVT() { + if m != nil { + f0 := m.Transactions[:0] + for _, mm := range m.Withdrawals { + mm.ResetVT() + } + f1 := m.Withdrawals[:0] + m.Reset() + m.Transactions = f0 + m.Withdrawals = f1 + } +} +func (m *ExecutionPayloadCapellaV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadCapellaV2.Put(m) + } +} +func ExecutionPayloadCapellaV2FromVTPool() *ExecutionPayloadCapellaV2 { + return vtprotoPool_ExecutionPayloadCapellaV2.Get().(*ExecutionPayloadCapellaV2) +} + +var vtprotoPool_ExecutionPayloadDeneb = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadDeneb{} + }, +} + +func (m *ExecutionPayloadDeneb) ResetVT() { + if m != nil { + f0 := m.Transactions[:0] + for _, mm := range m.Withdrawals { + mm.ResetVT() + } + f1 := m.Withdrawals[:0] + m.Reset() + m.Transactions = f0 + m.Withdrawals = f1 + } +} +func (m *ExecutionPayloadDeneb) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadDeneb.Put(m) + } +} +func ExecutionPayloadDenebFromVTPool() *ExecutionPayloadDeneb { + return vtprotoPool_ExecutionPayloadDeneb.Get().(*ExecutionPayloadDeneb) +} + +var vtprotoPool_ExecutionPayloadElectra = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadElectra{} + }, +} + +func (m *ExecutionPayloadElectra) ResetVT() { + if m != nil { + f0 := m.Transactions[:0] + for _, mm := range m.Withdrawals { + mm.ResetVT() + } + f1 := m.Withdrawals[:0] + m.Reset() + m.Transactions = f0 + m.Withdrawals = f1 + } +} +func (m *ExecutionPayloadElectra) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadElectra.Put(m) + } +} +func ExecutionPayloadElectraFromVTPool() *ExecutionPayloadElectra { + return vtprotoPool_ExecutionPayloadElectra.Get().(*ExecutionPayloadElectra) +} + +var vtprotoPool_ExecutionPayloadFulu = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadFulu{} + }, +} + +func (m *ExecutionPayloadFulu) ResetVT() { + if m != nil { + f0 := m.Transactions[:0] + for _, mm := range m.Withdrawals { + mm.ResetVT() + } + f1 := m.Withdrawals[:0] + m.Reset() + m.Transactions = f0 + m.Withdrawals = f1 + } +} +func (m *ExecutionPayloadFulu) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadFulu.Put(m) + } +} +func ExecutionPayloadFuluFromVTPool() *ExecutionPayloadFulu { + return vtprotoPool_ExecutionPayloadFulu.Get().(*ExecutionPayloadFulu) +} + +var vtprotoPool_Withdrawal = sync.Pool{ + New: func() interface{} { + return &Withdrawal{} + }, +} + +func (m *Withdrawal) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Withdrawal) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Withdrawal.Put(m) + } +} +func WithdrawalFromVTPool() *Withdrawal { + return vtprotoPool_Withdrawal.Get().(*Withdrawal) +} + +var vtprotoPool_WithdrawalV2 = sync.Pool{ + New: func() interface{} { + return &WithdrawalV2{} + }, +} + +func (m *WithdrawalV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *WithdrawalV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_WithdrawalV2.Put(m) + } +} +func WithdrawalV2FromVTPool() *WithdrawalV2 { + return vtprotoPool_WithdrawalV2.Get().(*WithdrawalV2) +} + +var vtprotoPool_ExecutionPayloadHeaderCapella = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadHeaderCapella{} + }, +} + +func (m *ExecutionPayloadHeaderCapella) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionPayloadHeaderCapella) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadHeaderCapella.Put(m) + } +} +func ExecutionPayloadHeaderCapellaFromVTPool() *ExecutionPayloadHeaderCapella { + return vtprotoPool_ExecutionPayloadHeaderCapella.Get().(*ExecutionPayloadHeaderCapella) +} + +var vtprotoPool_ExecutionPayloadHeaderCapellaV2 = sync.Pool{ + New: func() interface{} { + return &ExecutionPayloadHeaderCapellaV2{} + }, +} + +func (m *ExecutionPayloadHeaderCapellaV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionPayloadHeaderCapellaV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionPayloadHeaderCapellaV2.Put(m) + } +} +func ExecutionPayloadHeaderCapellaV2FromVTPool() *ExecutionPayloadHeaderCapellaV2 { + return vtprotoPool_ExecutionPayloadHeaderCapellaV2.Get().(*ExecutionPayloadHeaderCapellaV2) +} + +var vtprotoPool_Transaction = sync.Pool{ + New: func() interface{} { + return &Transaction{} + }, +} + +func (m *Transaction) ResetVT() { + if m != nil { + f0 := m.BlobHashes[:0] + m.Reset() + m.BlobHashes = f0 + } +} +func (m *Transaction) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Transaction.Put(m) + } +} +func TransactionFromVTPool() *Transaction { + return vtprotoPool_Transaction.Get().(*Transaction) +} +func (m *ExecutionPayload) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BlockNumber)) + } + if m.GasLimit != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.GasLimit)) + } + if m.GasUsed != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.GasUsed)) + } + if m.Timestamp != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Timestamp)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Transactions) > 0 { + for _, s := range m.Transactions { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.UInt64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Transactions) > 0 { + for _, s := range m.Transactions { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadHeader) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BlockNumber)) + } + if m.GasLimit != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.GasLimit)) + } + if m.GasUsed != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.GasUsed)) + } + if m.Timestamp != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Timestamp)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.TransactionsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadHeaderV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.UInt64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.TransactionsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadCapella) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BlockNumber)) + } + if m.GasLimit != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.GasLimit)) + } + if m.GasUsed != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.GasUsed)) + } + if m.Timestamp != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Timestamp)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Transactions) > 0 { + for _, s := range m.Transactions { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Withdrawals) > 0 { + for _, e := range m.Withdrawals { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadCapellaV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.UInt64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Transactions) > 0 { + for _, s := range m.Transactions { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Withdrawals) > 0 { + for _, e := range m.Withdrawals { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadDeneb) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.UInt64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Transactions) > 0 { + for _, s := range m.Transactions { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Withdrawals) > 0 { + for _, e := range m.Withdrawals { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.BlobGasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.BlobGasUsed).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExcessBlobGas != nil { + l = (*wrapperspb.UInt64Value)(m.ExcessBlobGas).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadElectra) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.UInt64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Transactions) > 0 { + for _, s := range m.Transactions { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Withdrawals) > 0 { + for _, e := range m.Withdrawals { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.BlobGasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.BlobGasUsed).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExcessBlobGas != nil { + l = (*wrapperspb.UInt64Value)(m.ExcessBlobGas).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadFulu) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.UInt64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Transactions) > 0 { + for _, s := range m.Transactions { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Withdrawals) > 0 { + for _, e := range m.Withdrawals { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.BlobGasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.BlobGasUsed).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExcessBlobGas != nil { + l = (*wrapperspb.UInt64Value)(m.ExcessBlobGas).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Withdrawal) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Index)) + } + if m.ValidatorIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ValidatorIndex)) + } + l = len(m.Address) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Amount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Amount)) + } + n += len(m.unknownFields) + return n +} + +func (m *WithdrawalV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ValidatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ValidatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Address) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Amount != nil { + l = (*wrapperspb.UInt64Value)(m.Amount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadHeaderCapella) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BlockNumber)) + } + if m.GasLimit != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.GasLimit)) + } + if m.GasUsed != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.GasUsed)) + } + if m.Timestamp != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Timestamp)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.TransactionsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.WithdrawalsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayloadHeaderCapellaV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FeeRecipient) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ReceiptsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LogsBloom) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PrevRandao) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.UInt64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BaseFeePerGas) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.TransactionsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.WithdrawalsRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Transaction) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Input) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Gas != nil { + l = (*wrapperspb.UInt64Value)(m.Gas).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.GasPrice) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.From) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.To) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Nonce != nil { + l = (*wrapperspb.UInt64Value)(m.Nonce).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Type != nil { + l = (*wrapperspb.UInt32Value)(m.Type).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.GasTipCap) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.GasFeeCap) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlobGas != nil { + l = (*wrapperspb.UInt64Value)(m.BlobGas).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlobGasFeeCap) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlobHashes) > 0 { + for _, s := range m.BlobHashes { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionPayload) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayload: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayload: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + m.BlockNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + m.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + m.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + m.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Timestamp |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Transactions = append(m.Transactions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Transactions = append(m.Transactions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadHeader) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + m.BlockNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + m.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + m.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + m.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Timestamp |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TransactionsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadHeaderV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadHeaderV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadHeaderV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TransactionsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadCapella) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadCapella: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadCapella: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + m.BlockNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + m.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + m.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + m.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Timestamp |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Transactions = append(m.Transactions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawals", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Withdrawals) == cap(m.Withdrawals) { + m.Withdrawals = append(m.Withdrawals, &Withdrawal{}) + } else { + m.Withdrawals = m.Withdrawals[:len(m.Withdrawals)+1] + if m.Withdrawals[len(m.Withdrawals)-1] == nil { + m.Withdrawals[len(m.Withdrawals)-1] = &Withdrawal{} + } + } + if err := m.Withdrawals[len(m.Withdrawals)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadCapellaV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadCapellaV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadCapellaV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Transactions = append(m.Transactions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawals", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Withdrawals) == cap(m.Withdrawals) { + m.Withdrawals = append(m.Withdrawals, &WithdrawalV2{}) + } else { + m.Withdrawals = m.Withdrawals[:len(m.Withdrawals)+1] + if m.Withdrawals[len(m.Withdrawals)-1] == nil { + m.Withdrawals[len(m.Withdrawals)-1] = &WithdrawalV2{} + } + } + if err := m.Withdrawals[len(m.Withdrawals)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadDeneb) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadDeneb: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadDeneb: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Transactions = append(m.Transactions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawals", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Withdrawals) == cap(m.Withdrawals) { + m.Withdrawals = append(m.Withdrawals, &WithdrawalV2{}) + } else { + m.Withdrawals = m.Withdrawals[:len(m.Withdrawals)+1] + if m.Withdrawals[len(m.Withdrawals)-1] == nil { + m.Withdrawals[len(m.Withdrawals)-1] = &WithdrawalV2{} + } + } + if err := m.Withdrawals[len(m.Withdrawals)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobGasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlobGasUsed == nil { + m.BlobGasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlobGasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExcessBlobGas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExcessBlobGas == nil { + m.ExcessBlobGas = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ExcessBlobGas).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadElectra) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadElectra: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadElectra: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Transactions = append(m.Transactions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawals", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Withdrawals) == cap(m.Withdrawals) { + m.Withdrawals = append(m.Withdrawals, &WithdrawalV2{}) + } else { + m.Withdrawals = m.Withdrawals[:len(m.Withdrawals)+1] + if m.Withdrawals[len(m.Withdrawals)-1] == nil { + m.Withdrawals[len(m.Withdrawals)-1] = &WithdrawalV2{} + } + } + if err := m.Withdrawals[len(m.Withdrawals)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobGasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlobGasUsed == nil { + m.BlobGasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlobGasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExcessBlobGas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExcessBlobGas == nil { + m.ExcessBlobGas = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ExcessBlobGas).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadFulu) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadFulu: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadFulu: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Transactions = append(m.Transactions, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawals", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Withdrawals) == cap(m.Withdrawals) { + m.Withdrawals = append(m.Withdrawals, &WithdrawalV2{}) + } else { + m.Withdrawals = m.Withdrawals[:len(m.Withdrawals)+1] + if m.Withdrawals[len(m.Withdrawals)-1] == nil { + m.Withdrawals[len(m.Withdrawals)-1] = &WithdrawalV2{} + } + } + if err := m.Withdrawals[len(m.Withdrawals)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobGasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlobGasUsed == nil { + m.BlobGasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlobGasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExcessBlobGas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExcessBlobGas == nil { + m.ExcessBlobGas = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ExcessBlobGas).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Withdrawal) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Withdrawal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Withdrawal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + m.ValidatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + m.Amount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Amount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WithdrawalV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WithdrawalV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WithdrawalV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorIndex == nil { + m.ValidatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Amount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadHeaderCapella) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadHeaderCapella: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadHeaderCapella: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + m.BlockNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + m.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + m.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + m.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Timestamp |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TransactionsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawalsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithdrawalsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionPayloadHeaderCapellaV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionPayloadHeaderCapellaV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionPayloadHeaderCapellaV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeeRecipient = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReceiptsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsBloom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogsBloom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrevRandao", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrevRandao = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFeePerGas", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BaseFeePerGas = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TransactionsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawalsRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WithdrawalsRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Transaction) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Transaction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Transaction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Input = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Gas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Gas == nil { + m.Gas = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Gas).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasPrice", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GasPrice = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.From = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.To = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nonce == nil { + m.Nonce = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Nonce).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Type == nil { + m.Type = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Type).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasTipCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GasTipCap = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasFeeCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GasFeeCap = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobGas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlobGas == nil { + m.BlobGas = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlobGas).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobGasFeeCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobGasFeeCap = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobHashes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobHashes = append(m.BlobHashes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/execution_requests_vtproto.pb.go b/pkg/proto/eth/v1/execution_requests_vtproto.pb.go new file mode 100644 index 000000000..d1ee84185 --- /dev/null +++ b/pkg/proto/eth/v1/execution_requests_vtproto.pb.go @@ -0,0 +1,1224 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/execution_requests.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *ElectraExecutionRequests) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ElectraExecutionRequests) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ElectraExecutionRequests) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Consolidations) > 0 { + for iNdEx := len(m.Consolidations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Consolidations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Withdrawals) > 0 { + for iNdEx := len(m.Withdrawals) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Withdrawals[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ElectraExecutionRequestDeposit) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ElectraExecutionRequestDeposit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ElectraExecutionRequestDeposit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Signature != nil { + size, err := (*wrapperspb.StringValue)(m.Signature).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Amount != nil { + size, err := (*wrapperspb.UInt64Value)(m.Amount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.WithdrawalCredentials != nil { + size, err := (*wrapperspb.StringValue)(m.WithdrawalCredentials).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Pubkey != nil { + size, err := (*wrapperspb.StringValue)(m.Pubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ElectraExecutionRequestWithdrawal) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ElectraExecutionRequestWithdrawal) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ElectraExecutionRequestWithdrawal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Amount != nil { + size, err := (*wrapperspb.UInt64Value)(m.Amount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.ValidatorPubkey != nil { + size, err := (*wrapperspb.StringValue)(m.ValidatorPubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.SourceAddress != nil { + size, err := (*wrapperspb.StringValue)(m.SourceAddress).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ElectraExecutionRequestConsolidation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ElectraExecutionRequestConsolidation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ElectraExecutionRequestConsolidation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.TargetPubkey != nil { + size, err := (*wrapperspb.StringValue)(m.TargetPubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.SourcePubkey != nil { + size, err := (*wrapperspb.StringValue)(m.SourcePubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.SourceAddress != nil { + size, err := (*wrapperspb.StringValue)(m.SourceAddress).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_ElectraExecutionRequests = sync.Pool{ + New: func() interface{} { + return &ElectraExecutionRequests{} + }, +} + +func (m *ElectraExecutionRequests) ResetVT() { + if m != nil { + for _, mm := range m.Deposits { + mm.ResetVT() + } + f0 := m.Deposits[:0] + for _, mm := range m.Withdrawals { + mm.ResetVT() + } + f1 := m.Withdrawals[:0] + for _, mm := range m.Consolidations { + mm.ResetVT() + } + f2 := m.Consolidations[:0] + m.Reset() + m.Deposits = f0 + m.Withdrawals = f1 + m.Consolidations = f2 + } +} +func (m *ElectraExecutionRequests) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ElectraExecutionRequests.Put(m) + } +} +func ElectraExecutionRequestsFromVTPool() *ElectraExecutionRequests { + return vtprotoPool_ElectraExecutionRequests.Get().(*ElectraExecutionRequests) +} + +var vtprotoPool_ElectraExecutionRequestDeposit = sync.Pool{ + New: func() interface{} { + return &ElectraExecutionRequestDeposit{} + }, +} + +func (m *ElectraExecutionRequestDeposit) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ElectraExecutionRequestDeposit) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ElectraExecutionRequestDeposit.Put(m) + } +} +func ElectraExecutionRequestDepositFromVTPool() *ElectraExecutionRequestDeposit { + return vtprotoPool_ElectraExecutionRequestDeposit.Get().(*ElectraExecutionRequestDeposit) +} + +var vtprotoPool_ElectraExecutionRequestWithdrawal = sync.Pool{ + New: func() interface{} { + return &ElectraExecutionRequestWithdrawal{} + }, +} + +func (m *ElectraExecutionRequestWithdrawal) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ElectraExecutionRequestWithdrawal) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ElectraExecutionRequestWithdrawal.Put(m) + } +} +func ElectraExecutionRequestWithdrawalFromVTPool() *ElectraExecutionRequestWithdrawal { + return vtprotoPool_ElectraExecutionRequestWithdrawal.Get().(*ElectraExecutionRequestWithdrawal) +} + +var vtprotoPool_ElectraExecutionRequestConsolidation = sync.Pool{ + New: func() interface{} { + return &ElectraExecutionRequestConsolidation{} + }, +} + +func (m *ElectraExecutionRequestConsolidation) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ElectraExecutionRequestConsolidation) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ElectraExecutionRequestConsolidation.Put(m) + } +} +func ElectraExecutionRequestConsolidationFromVTPool() *ElectraExecutionRequestConsolidation { + return vtprotoPool_ElectraExecutionRequestConsolidation.Get().(*ElectraExecutionRequestConsolidation) +} +func (m *ElectraExecutionRequests) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Withdrawals) > 0 { + for _, e := range m.Withdrawals { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Consolidations) > 0 { + for _, e := range m.Consolidations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ElectraExecutionRequestDeposit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pubkey != nil { + l = (*wrapperspb.StringValue)(m.Pubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WithdrawalCredentials != nil { + l = (*wrapperspb.StringValue)(m.WithdrawalCredentials).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Amount != nil { + l = (*wrapperspb.UInt64Value)(m.Amount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Signature != nil { + l = (*wrapperspb.StringValue)(m.Signature).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ElectraExecutionRequestWithdrawal) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SourceAddress != nil { + l = (*wrapperspb.StringValue)(m.SourceAddress).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ValidatorPubkey != nil { + l = (*wrapperspb.StringValue)(m.ValidatorPubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Amount != nil { + l = (*wrapperspb.UInt64Value)(m.Amount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ElectraExecutionRequestConsolidation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SourceAddress != nil { + l = (*wrapperspb.StringValue)(m.SourceAddress).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SourcePubkey != nil { + l = (*wrapperspb.StringValue)(m.SourcePubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TargetPubkey != nil { + l = (*wrapperspb.StringValue)(m.TargetPubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ElectraExecutionRequests) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ElectraExecutionRequests: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ElectraExecutionRequests: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &ElectraExecutionRequestDeposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &ElectraExecutionRequestDeposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Withdrawals", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Withdrawals) == cap(m.Withdrawals) { + m.Withdrawals = append(m.Withdrawals, &ElectraExecutionRequestWithdrawal{}) + } else { + m.Withdrawals = m.Withdrawals[:len(m.Withdrawals)+1] + if m.Withdrawals[len(m.Withdrawals)-1] == nil { + m.Withdrawals[len(m.Withdrawals)-1] = &ElectraExecutionRequestWithdrawal{} + } + } + if err := m.Withdrawals[len(m.Withdrawals)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Consolidations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Consolidations) == cap(m.Consolidations) { + m.Consolidations = append(m.Consolidations, &ElectraExecutionRequestConsolidation{}) + } else { + m.Consolidations = m.Consolidations[:len(m.Consolidations)+1] + if m.Consolidations[len(m.Consolidations)-1] == nil { + m.Consolidations[len(m.Consolidations)-1] = &ElectraExecutionRequestConsolidation{} + } + } + if err := m.Consolidations[len(m.Consolidations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ElectraExecutionRequestDeposit) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ElectraExecutionRequestDeposit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ElectraExecutionRequestDeposit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pubkey == nil { + m.Pubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Pubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawalCredentials", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WithdrawalCredentials == nil { + m.WithdrawalCredentials = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.WithdrawalCredentials).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Amount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Signature == nil { + m.Signature = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Signature).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ElectraExecutionRequestWithdrawal) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ElectraExecutionRequestWithdrawal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ElectraExecutionRequestWithdrawal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SourceAddress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SourceAddress == nil { + m.SourceAddress = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.SourceAddress).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorPubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorPubkey == nil { + m.ValidatorPubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ValidatorPubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Amount == nil { + m.Amount = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Amount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ElectraExecutionRequestConsolidation) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ElectraExecutionRequestConsolidation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ElectraExecutionRequestConsolidation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SourceAddress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SourceAddress == nil { + m.SourceAddress = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.SourceAddress).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SourcePubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SourcePubkey == nil { + m.SourcePubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.SourcePubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TargetPubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TargetPubkey == nil { + m.TargetPubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TargetPubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/fork_choice_vtproto.pb.go b/pkg/proto/eth/v1/fork_choice_vtproto.pb.go new file mode 100644 index 000000000..28c4e80d5 --- /dev/null +++ b/pkg/proto/eth/v1/fork_choice_vtproto.pb.go @@ -0,0 +1,1552 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/fork_choice.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *ForkChoice) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ForkChoice) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ForkChoice) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ForkChoiceNodes) > 0 { + for iNdEx := len(m.ForkChoiceNodes) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ForkChoiceNodes[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if m.FinalizedCheckpoint != nil { + size, err := m.FinalizedCheckpoint.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.JustifiedCheckpoint != nil { + size, err := m.JustifiedCheckpoint.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ForkChoiceV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ForkChoiceV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ForkChoiceV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ForkChoiceNodes) > 0 { + for iNdEx := len(m.ForkChoiceNodes) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ForkChoiceNodes[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if m.FinalizedCheckpoint != nil { + size, err := m.FinalizedCheckpoint.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.JustifiedCheckpoint != nil { + size, err := m.JustifiedCheckpoint.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ForkChoiceNode) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ForkChoiceNode) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ForkChoiceNode) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x4a + } + if len(m.ExecutionBlockHash) > 0 { + i -= len(m.ExecutionBlockHash) + copy(dAtA[i:], m.ExecutionBlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExecutionBlockHash))) + i-- + dAtA[i] = 0x42 + } + if len(m.Validity) > 0 { + i -= len(m.Validity) + copy(dAtA[i:], m.Validity) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Validity))) + i-- + dAtA[i] = 0x3a + } + if m.Weight != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Weight)) + i-- + dAtA[i] = 0x30 + } + if m.FinalizedEpoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FinalizedEpoch)) + i-- + dAtA[i] = 0x28 + } + if m.JustifiedEpoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.JustifiedEpoch)) + i-- + dAtA[i] = 0x20 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x12 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ForkChoiceNodeV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ForkChoiceNodeV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ForkChoiceNodeV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ExtraData) > 0 { + i -= len(m.ExtraData) + copy(dAtA[i:], m.ExtraData) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtraData))) + i-- + dAtA[i] = 0x4a + } + if len(m.ExecutionBlockHash) > 0 { + i -= len(m.ExecutionBlockHash) + copy(dAtA[i:], m.ExecutionBlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExecutionBlockHash))) + i-- + dAtA[i] = 0x42 + } + if len(m.Validity) > 0 { + i -= len(m.Validity) + copy(dAtA[i:], m.Validity) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Validity))) + i-- + dAtA[i] = 0x3a + } + if m.Weight != nil { + size, err := (*wrapperspb.UInt64Value)(m.Weight).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.FinalizedEpoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.FinalizedEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.JustifiedEpoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.JustifiedEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_ForkChoice = sync.Pool{ + New: func() interface{} { + return &ForkChoice{} + }, +} + +func (m *ForkChoice) ResetVT() { + if m != nil { + m.JustifiedCheckpoint.ReturnToVTPool() + m.FinalizedCheckpoint.ReturnToVTPool() + for _, mm := range m.ForkChoiceNodes { + mm.ResetVT() + } + f0 := m.ForkChoiceNodes[:0] + m.Reset() + m.ForkChoiceNodes = f0 + } +} +func (m *ForkChoice) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ForkChoice.Put(m) + } +} +func ForkChoiceFromVTPool() *ForkChoice { + return vtprotoPool_ForkChoice.Get().(*ForkChoice) +} + +var vtprotoPool_ForkChoiceV2 = sync.Pool{ + New: func() interface{} { + return &ForkChoiceV2{} + }, +} + +func (m *ForkChoiceV2) ResetVT() { + if m != nil { + m.JustifiedCheckpoint.ReturnToVTPool() + m.FinalizedCheckpoint.ReturnToVTPool() + for _, mm := range m.ForkChoiceNodes { + mm.ResetVT() + } + f0 := m.ForkChoiceNodes[:0] + m.Reset() + m.ForkChoiceNodes = f0 + } +} +func (m *ForkChoiceV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ForkChoiceV2.Put(m) + } +} +func ForkChoiceV2FromVTPool() *ForkChoiceV2 { + return vtprotoPool_ForkChoiceV2.Get().(*ForkChoiceV2) +} + +var vtprotoPool_ForkChoiceNode = sync.Pool{ + New: func() interface{} { + return &ForkChoiceNode{} + }, +} + +func (m *ForkChoiceNode) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ForkChoiceNode) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ForkChoiceNode.Put(m) + } +} +func ForkChoiceNodeFromVTPool() *ForkChoiceNode { + return vtprotoPool_ForkChoiceNode.Get().(*ForkChoiceNode) +} + +var vtprotoPool_ForkChoiceNodeV2 = sync.Pool{ + New: func() interface{} { + return &ForkChoiceNodeV2{} + }, +} + +func (m *ForkChoiceNodeV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ForkChoiceNodeV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ForkChoiceNodeV2.Put(m) + } +} +func ForkChoiceNodeV2FromVTPool() *ForkChoiceNodeV2 { + return vtprotoPool_ForkChoiceNodeV2.Get().(*ForkChoiceNodeV2) +} +func (m *ForkChoice) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.JustifiedCheckpoint != nil { + l = m.JustifiedCheckpoint.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedCheckpoint != nil { + l = m.FinalizedCheckpoint.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ForkChoiceNodes) > 0 { + for _, e := range m.ForkChoiceNodes { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ForkChoiceV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.JustifiedCheckpoint != nil { + l = m.JustifiedCheckpoint.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedCheckpoint != nil { + l = m.FinalizedCheckpoint.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ForkChoiceNodes) > 0 { + for _, e := range m.ForkChoiceNodes { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ForkChoiceNode) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.JustifiedEpoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.JustifiedEpoch)) + } + if m.FinalizedEpoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.FinalizedEpoch)) + } + if m.Weight != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Weight)) + } + l = len(m.Validity) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExecutionBlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ForkChoiceNodeV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.JustifiedEpoch != nil { + l = (*wrapperspb.UInt64Value)(m.JustifiedEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedEpoch != nil { + l = (*wrapperspb.UInt64Value)(m.FinalizedEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Weight != nil { + l = (*wrapperspb.UInt64Value)(m.Weight).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Validity) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExecutionBlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExtraData) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ForkChoice) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ForkChoice: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ForkChoice: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JustifiedCheckpoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JustifiedCheckpoint == nil { + m.JustifiedCheckpoint = CheckpointFromVTPool() + } + if err := m.JustifiedCheckpoint.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedCheckpoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedCheckpoint == nil { + m.FinalizedCheckpoint = CheckpointFromVTPool() + } + if err := m.FinalizedCheckpoint.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkChoiceNodes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ForkChoiceNodes) == cap(m.ForkChoiceNodes) { + m.ForkChoiceNodes = append(m.ForkChoiceNodes, &ForkChoiceNode{}) + } else { + m.ForkChoiceNodes = m.ForkChoiceNodes[:len(m.ForkChoiceNodes)+1] + if m.ForkChoiceNodes[len(m.ForkChoiceNodes)-1] == nil { + m.ForkChoiceNodes[len(m.ForkChoiceNodes)-1] = &ForkChoiceNode{} + } + } + if err := m.ForkChoiceNodes[len(m.ForkChoiceNodes)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ForkChoiceV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ForkChoiceV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ForkChoiceV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JustifiedCheckpoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JustifiedCheckpoint == nil { + m.JustifiedCheckpoint = CheckpointV2FromVTPool() + } + if err := m.JustifiedCheckpoint.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedCheckpoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedCheckpoint == nil { + m.FinalizedCheckpoint = CheckpointV2FromVTPool() + } + if err := m.FinalizedCheckpoint.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkChoiceNodes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ForkChoiceNodes) == cap(m.ForkChoiceNodes) { + m.ForkChoiceNodes = append(m.ForkChoiceNodes, &ForkChoiceNodeV2{}) + } else { + m.ForkChoiceNodes = m.ForkChoiceNodes[:len(m.ForkChoiceNodes)+1] + if m.ForkChoiceNodes[len(m.ForkChoiceNodes)-1] == nil { + m.ForkChoiceNodes[len(m.ForkChoiceNodes)-1] = &ForkChoiceNodeV2{} + } + } + if err := m.ForkChoiceNodes[len(m.ForkChoiceNodes)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ForkChoiceNode) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ForkChoiceNode: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ForkChoiceNode: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field JustifiedEpoch", wireType) + } + m.JustifiedEpoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.JustifiedEpoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpoch", wireType) + } + m.FinalizedEpoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FinalizedEpoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType) + } + m.Weight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Weight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validity", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Validity = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionBlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExecutionBlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ForkChoiceNodeV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ForkChoiceNodeV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ForkChoiceNodeV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JustifiedEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JustifiedEpoch == nil { + m.JustifiedEpoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.JustifiedEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedEpoch == nil { + m.FinalizedEpoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.FinalizedEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Weight == nil { + m.Weight = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Weight).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validity", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Validity = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionBlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExecutionBlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtraData = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/sync_committee_vtproto.pb.go b/pkg/proto/eth/v1/sync_committee_vtproto.pb.go new file mode 100644 index 000000000..9272d814d --- /dev/null +++ b/pkg/proto/eth/v1/sync_committee_vtproto.pb.go @@ -0,0 +1,1086 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/sync_committee.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *SyncCommitteeContribution) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncCommitteeContribution) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SyncCommitteeContribution) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BeaconBlockRoot) > 0 { + i -= len(m.BeaconBlockRoot) + copy(dAtA[i:], m.BeaconBlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BeaconBlockRoot))) + i-- + dAtA[i] = 0x2a + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 + } + if len(m.AggregationBits) > 0 { + i -= len(m.AggregationBits) + copy(dAtA[i:], m.AggregationBits) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AggregationBits))) + i-- + dAtA[i] = 0x1a + } + if m.SubcommitteeIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SubcommitteeIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SyncCommitteeContributionV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncCommitteeContributionV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SyncCommitteeContributionV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BeaconBlockRoot) > 0 { + i -= len(m.BeaconBlockRoot) + copy(dAtA[i:], m.BeaconBlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BeaconBlockRoot))) + i-- + dAtA[i] = 0x2a + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 + } + if len(m.AggregationBits) > 0 { + i -= len(m.AggregationBits) + copy(dAtA[i:], m.AggregationBits) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AggregationBits))) + i-- + dAtA[i] = 0x1a + } + if m.SubcommitteeIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.SubcommitteeIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SyncCommitteeValidatorAggregate) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncCommitteeValidatorAggregate) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SyncCommitteeValidatorAggregate) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Validators) > 0 { + for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.UInt64Value)(m.Validators[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *SyncCommittee) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SyncCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ValidatorAggregates) > 0 { + for iNdEx := len(m.ValidatorAggregates) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ValidatorAggregates[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Validators) > 0 { + for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.UInt64Value)(m.Validators[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +var vtprotoPool_SyncCommitteeContribution = sync.Pool{ + New: func() interface{} { + return &SyncCommitteeContribution{} + }, +} + +func (m *SyncCommitteeContribution) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *SyncCommitteeContribution) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SyncCommitteeContribution.Put(m) + } +} +func SyncCommitteeContributionFromVTPool() *SyncCommitteeContribution { + return vtprotoPool_SyncCommitteeContribution.Get().(*SyncCommitteeContribution) +} + +var vtprotoPool_SyncCommitteeContributionV2 = sync.Pool{ + New: func() interface{} { + return &SyncCommitteeContributionV2{} + }, +} + +func (m *SyncCommitteeContributionV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *SyncCommitteeContributionV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SyncCommitteeContributionV2.Put(m) + } +} +func SyncCommitteeContributionV2FromVTPool() *SyncCommitteeContributionV2 { + return vtprotoPool_SyncCommitteeContributionV2.Get().(*SyncCommitteeContributionV2) +} + +var vtprotoPool_SyncCommitteeValidatorAggregate = sync.Pool{ + New: func() interface{} { + return &SyncCommitteeValidatorAggregate{} + }, +} + +func (m *SyncCommitteeValidatorAggregate) ResetVT() { + if m != nil { + for _, mm := range m.Validators { + mm.Reset() + } + f0 := m.Validators[:0] + m.Reset() + m.Validators = f0 + } +} +func (m *SyncCommitteeValidatorAggregate) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SyncCommitteeValidatorAggregate.Put(m) + } +} +func SyncCommitteeValidatorAggregateFromVTPool() *SyncCommitteeValidatorAggregate { + return vtprotoPool_SyncCommitteeValidatorAggregate.Get().(*SyncCommitteeValidatorAggregate) +} + +var vtprotoPool_SyncCommittee = sync.Pool{ + New: func() interface{} { + return &SyncCommittee{} + }, +} + +func (m *SyncCommittee) ResetVT() { + if m != nil { + for _, mm := range m.Validators { + mm.Reset() + } + f0 := m.Validators[:0] + for _, mm := range m.ValidatorAggregates { + mm.ResetVT() + } + f1 := m.ValidatorAggregates[:0] + m.Reset() + m.Validators = f0 + m.ValidatorAggregates = f1 + } +} +func (m *SyncCommittee) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SyncCommittee.Put(m) + } +} +func SyncCommitteeFromVTPool() *SyncCommittee { + return vtprotoPool_SyncCommittee.Get().(*SyncCommittee) +} +func (m *SyncCommitteeContribution) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.SubcommitteeIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.SubcommitteeIndex)) + } + l = len(m.AggregationBits) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BeaconBlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SyncCommitteeContributionV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SubcommitteeIndex != nil { + l = (*wrapperspb.UInt64Value)(m.SubcommitteeIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.AggregationBits) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BeaconBlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SyncCommitteeValidatorAggregate) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Validators) > 0 { + for _, e := range m.Validators { + l = (*wrapperspb.UInt64Value)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *SyncCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Validators) > 0 { + for _, e := range m.Validators { + l = (*wrapperspb.UInt64Value)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.ValidatorAggregates) > 0 { + for _, e := range m.ValidatorAggregates { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *SyncCommitteeContribution) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyncCommitteeContribution: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncCommitteeContribution: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SubcommitteeIndex", wireType) + } + m.SubcommitteeIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SubcommitteeIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregationBits", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AggregationBits = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BeaconBlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyncCommitteeContributionV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyncCommitteeContributionV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncCommitteeContributionV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubcommitteeIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SubcommitteeIndex == nil { + m.SubcommitteeIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SubcommitteeIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregationBits", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AggregationBits = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BeaconBlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyncCommitteeValidatorAggregate) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyncCommitteeValidatorAggregate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncCommitteeValidatorAggregate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Validators) == cap(m.Validators) { + m.Validators = append(m.Validators, &wrapperspb1.UInt64Value{}) + } else { + m.Validators = m.Validators[:len(m.Validators)+1] + if m.Validators[len(m.Validators)-1] == nil { + m.Validators[len(m.Validators)-1] = &wrapperspb1.UInt64Value{} + } + } + if err := (*wrapperspb.UInt64Value)(m.Validators[len(m.Validators)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyncCommittee) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyncCommittee: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncCommittee: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Validators) == cap(m.Validators) { + m.Validators = append(m.Validators, &wrapperspb1.UInt64Value{}) + } else { + m.Validators = m.Validators[:len(m.Validators)+1] + if m.Validators[len(m.Validators)-1] == nil { + m.Validators[len(m.Validators)-1] = &wrapperspb1.UInt64Value{} + } + } + if err := (*wrapperspb.UInt64Value)(m.Validators[len(m.Validators)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAggregates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ValidatorAggregates) == cap(m.ValidatorAggregates) { + m.ValidatorAggregates = append(m.ValidatorAggregates, &SyncCommitteeValidatorAggregate{}) + } else { + m.ValidatorAggregates = m.ValidatorAggregates[:len(m.ValidatorAggregates)+1] + if m.ValidatorAggregates[len(m.ValidatorAggregates)-1] == nil { + m.ValidatorAggregates[len(m.ValidatorAggregates)-1] = &SyncCommitteeValidatorAggregate{} + } + } + if err := m.ValidatorAggregates[len(m.ValidatorAggregates)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v1/validator_vtproto.pb.go b/pkg/proto/eth/v1/validator_vtproto.pb.go new file mode 100644 index 000000000..51896afb1 --- /dev/null +++ b/pkg/proto/eth/v1/validator_vtproto.pb.go @@ -0,0 +1,853 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v1/validator.proto + +package v1 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *ValidatorData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValidatorData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ValidatorData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.WithdrawableEpoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.WithdrawableEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.ExitEpoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.ExitEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.ActivationEpoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.ActivationEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.ActivationEligibilityEpoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.ActivationEligibilityEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Slashed != nil { + size, err := (*wrapperspb.BoolValue)(m.Slashed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.EffectiveBalance != nil { + size, err := (*wrapperspb.UInt64Value)(m.EffectiveBalance).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.WithdrawalCredentials != nil { + size, err := (*wrapperspb.StringValue)(m.WithdrawalCredentials).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Pubkey != nil { + size, err := (*wrapperspb.StringValue)(m.Pubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Validator) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Validator) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Validator) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Status != nil { + size, err := (*wrapperspb.StringValue)(m.Status).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Balance != nil { + size, err := (*wrapperspb.UInt64Value)(m.Balance).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Data != nil { + size, err := m.Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_ValidatorData = sync.Pool{ + New: func() interface{} { + return &ValidatorData{} + }, +} + +func (m *ValidatorData) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ValidatorData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ValidatorData.Put(m) + } +} +func ValidatorDataFromVTPool() *ValidatorData { + return vtprotoPool_ValidatorData.Get().(*ValidatorData) +} + +var vtprotoPool_Validator = sync.Pool{ + New: func() interface{} { + return &Validator{} + }, +} + +func (m *Validator) ResetVT() { + if m != nil { + m.Data.ReturnToVTPool() + m.Reset() + } +} +func (m *Validator) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Validator.Put(m) + } +} +func ValidatorFromVTPool() *Validator { + return vtprotoPool_Validator.Get().(*Validator) +} +func (m *ValidatorData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pubkey != nil { + l = (*wrapperspb.StringValue)(m.Pubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WithdrawalCredentials != nil { + l = (*wrapperspb.StringValue)(m.WithdrawalCredentials).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.EffectiveBalance != nil { + l = (*wrapperspb.UInt64Value)(m.EffectiveBalance).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slashed != nil { + l = (*wrapperspb.BoolValue)(m.Slashed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ActivationEligibilityEpoch != nil { + l = (*wrapperspb.UInt64Value)(m.ActivationEligibilityEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ActivationEpoch != nil { + l = (*wrapperspb.UInt64Value)(m.ActivationEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExitEpoch != nil { + l = (*wrapperspb.UInt64Value)(m.ExitEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WithdrawableEpoch != nil { + l = (*wrapperspb.UInt64Value)(m.WithdrawableEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Validator) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Balance != nil { + l = (*wrapperspb.UInt64Value)(m.Balance).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Status != nil { + l = (*wrapperspb.StringValue)(m.Status).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ValidatorData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ValidatorData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pubkey == nil { + m.Pubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Pubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawalCredentials", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WithdrawalCredentials == nil { + m.WithdrawalCredentials = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.WithdrawalCredentials).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EffectiveBalance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EffectiveBalance == nil { + m.EffectiveBalance = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.EffectiveBalance).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slashed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slashed == nil { + m.Slashed = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Slashed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActivationEligibilityEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ActivationEligibilityEpoch == nil { + m.ActivationEligibilityEpoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ActivationEligibilityEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActivationEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ActivationEpoch == nil { + m.ActivationEpoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ActivationEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExitEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExitEpoch == nil { + m.ExitEpoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ExitEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawableEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WithdrawableEpoch == nil { + m.WithdrawableEpoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.WithdrawableEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Validator) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Validator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = ValidatorDataFromVTPool() + } + if err := m.Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Balance == nil { + m.Balance = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Balance).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Status == nil { + m.Status = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Status).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v2/beacon_block_vtproto.pb.go b/pkg/proto/eth/v2/beacon_block_vtproto.pb.go new file mode 100644 index 000000000..98bfb9389 --- /dev/null +++ b/pkg/proto/eth/v2/beacon_block_vtproto.pb.go @@ -0,0 +1,16443 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v2/beacon_block.proto + +package v2 + +import ( + fmt "fmt" + v1 "github.com/ethpandaops/xatu/pkg/proto/eth/v1" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *SignedBeaconBlockBellatrix) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockBellatrix) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockBellatrix) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockBellatrixV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockBellatrixV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockBellatrixV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockCapella) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockCapella) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockCapella) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockCapellaV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockCapellaV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockCapellaV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockDeneb) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockDeneb) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockDeneb) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockElectra) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockElectra) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockElectra) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockFulu) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockFulu) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockFulu) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBlindedBeaconBlockBellatrix) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBlindedBeaconBlockBellatrix) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBlindedBeaconBlockBellatrix) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBlindedBeaconBlockBellatrixV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBlindedBeaconBlockBellatrixV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBlindedBeaconBlockBellatrixV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBlindedBeaconBlockCapella) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBlindedBeaconBlockCapella) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBlindedBeaconBlockCapella) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBlindedBeaconBlockCapellaV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBlindedBeaconBlockCapellaV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBlindedBeaconBlockCapellaV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockAltair) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockAltair) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockAltair) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBeaconBlockAltairV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBeaconBlockAltairV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBeaconBlockAltairV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBellatrix) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBellatrix) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBellatrix) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProposerIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBellatrixV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBellatrixV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBellatrixV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlindedBeaconBlockBellatrix) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlindedBeaconBlockBellatrix) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlindedBeaconBlockBellatrix) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProposerIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BlindedBeaconBlockBellatrixV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlindedBeaconBlockBellatrixV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlindedBeaconBlockBellatrixV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockCapella) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockCapella) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockCapella) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProposerIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockCapellaV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockCapellaV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockCapellaV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockDeneb) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockDeneb) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockDeneb) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockElectra) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockElectra) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockElectra) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockFulu) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockFulu) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockFulu) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlindedBeaconBlockCapella) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlindedBeaconBlockCapella) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlindedBeaconBlockCapella) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProposerIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BlindedBeaconBlockCapellaV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlindedBeaconBlockCapellaV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlindedBeaconBlockCapellaV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockAltair) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockAltair) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockAltair) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProposerIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Slot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockAltairV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockAltairV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockAltairV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Body != nil { + size, err := m.Body.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.ParentRoot) > 0 { + i -= len(m.ParentRoot) + copy(dAtA[i:], m.ParentRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentRoot))) + i-- + dAtA[i] = 0x1a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyBellatrix) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyBellatrix) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyBellatrix) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExecutionPayload != nil { + size, err := m.ExecutionPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyBellatrixV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyBellatrixV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyBellatrixV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExecutionPayload != nil { + size, err := m.ExecutionPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlindedBeaconBlockBodyBellatrix) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlindedBeaconBlockBodyBellatrix) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlindedBeaconBlockBodyBellatrix) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExecutionPayloadHeader != nil { + size, err := m.ExecutionPayloadHeader.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlindedBeaconBlockBodyBellatrixV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlindedBeaconBlockBodyBellatrixV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlindedBeaconBlockBodyBellatrixV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExecutionPayloadHeader != nil { + size, err := m.ExecutionPayloadHeader.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyCapella) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyCapella) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyCapella) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlsToExecutionChanges) > 0 { + for iNdEx := len(m.BlsToExecutionChanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.BlsToExecutionChanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + } + if m.ExecutionPayload != nil { + size, err := m.ExecutionPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyCapellaV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyCapellaV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyCapellaV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlsToExecutionChanges) > 0 { + for iNdEx := len(m.BlsToExecutionChanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.BlsToExecutionChanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + } + if m.ExecutionPayload != nil { + size, err := m.ExecutionPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyDeneb) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyDeneb) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyDeneb) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlobKzgCommitments) > 0 { + for iNdEx := len(m.BlobKzgCommitments) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.BlobKzgCommitments[iNdEx]) + copy(dAtA[i:], m.BlobKzgCommitments[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobKzgCommitments[iNdEx]))) + i-- + dAtA[i] = 0x62 + } + } + if len(m.BlsToExecutionChanges) > 0 { + for iNdEx := len(m.BlsToExecutionChanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.BlsToExecutionChanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + } + if m.ExecutionPayload != nil { + size, err := m.ExecutionPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyElectra) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyElectra) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyElectra) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExecutionRequests != nil { + size, err := m.ExecutionRequests.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if len(m.BlobKzgCommitments) > 0 { + for iNdEx := len(m.BlobKzgCommitments) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.BlobKzgCommitments[iNdEx]) + copy(dAtA[i:], m.BlobKzgCommitments[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobKzgCommitments[iNdEx]))) + i-- + dAtA[i] = 0x62 + } + } + if len(m.BlsToExecutionChanges) > 0 { + for iNdEx := len(m.BlsToExecutionChanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.BlsToExecutionChanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + } + if m.ExecutionPayload != nil { + size, err := m.ExecutionPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyFulu) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyFulu) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyFulu) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ExecutionRequests != nil { + size, err := m.ExecutionRequests.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if len(m.BlobKzgCommitments) > 0 { + for iNdEx := len(m.BlobKzgCommitments) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.BlobKzgCommitments[iNdEx]) + copy(dAtA[i:], m.BlobKzgCommitments[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobKzgCommitments[iNdEx]))) + i-- + dAtA[i] = 0x62 + } + } + if len(m.BlsToExecutionChanges) > 0 { + for iNdEx := len(m.BlsToExecutionChanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.BlsToExecutionChanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + } + if m.ExecutionPayload != nil { + size, err := m.ExecutionPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlindedBeaconBlockBodyCapella) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlindedBeaconBlockBodyCapella) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlindedBeaconBlockBodyCapella) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlsToExecutionChanges) > 0 { + for iNdEx := len(m.BlsToExecutionChanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.BlsToExecutionChanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + } + if m.ExecutionPayloadHeader != nil { + size, err := m.ExecutionPayloadHeader.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlindedBeaconBlockBodyCapellaV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlindedBeaconBlockBodyCapellaV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlindedBeaconBlockBodyCapellaV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlsToExecutionChanges) > 0 { + for iNdEx := len(m.BlsToExecutionChanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.BlsToExecutionChanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + } + if m.ExecutionPayloadHeader != nil { + size, err := m.ExecutionPayloadHeader.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyAltair) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyAltair) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyAltair) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BeaconBlockBodyAltairV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlockBodyAltairV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlockBodyAltairV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SyncAggregate != nil { + size, err := m.SyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.VoluntaryExits) > 0 { + for iNdEx := len(m.VoluntaryExits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.VoluntaryExits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.Deposits) > 0 { + for iNdEx := len(m.Deposits) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deposits[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Attestations) > 0 { + for iNdEx := len(m.Attestations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Attestations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.AttesterSlashings) > 0 { + for iNdEx := len(m.AttesterSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AttesterSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.ProposerSlashings) > 0 { + for iNdEx := len(m.ProposerSlashings) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ProposerSlashings[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graffiti) > 0 { + i -= len(m.Graffiti) + copy(dAtA[i:], m.Graffiti) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Graffiti))) + i-- + dAtA[i] = 0x1a + } + if m.Eth1Data != nil { + size, err := m.Eth1Data.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.RandaoReveal) > 0 { + i -= len(m.RandaoReveal) + copy(dAtA[i:], m.RandaoReveal) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RandaoReveal))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_SignedBeaconBlockBellatrix = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockBellatrix{} + }, +} + +func (m *SignedBeaconBlockBellatrix) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockBellatrix) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockBellatrix.Put(m) + } +} +func SignedBeaconBlockBellatrixFromVTPool() *SignedBeaconBlockBellatrix { + return vtprotoPool_SignedBeaconBlockBellatrix.Get().(*SignedBeaconBlockBellatrix) +} + +var vtprotoPool_SignedBeaconBlockBellatrixV2 = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockBellatrixV2{} + }, +} + +func (m *SignedBeaconBlockBellatrixV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockBellatrixV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockBellatrixV2.Put(m) + } +} +func SignedBeaconBlockBellatrixV2FromVTPool() *SignedBeaconBlockBellatrixV2 { + return vtprotoPool_SignedBeaconBlockBellatrixV2.Get().(*SignedBeaconBlockBellatrixV2) +} + +var vtprotoPool_SignedBeaconBlockCapella = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockCapella{} + }, +} + +func (m *SignedBeaconBlockCapella) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockCapella) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockCapella.Put(m) + } +} +func SignedBeaconBlockCapellaFromVTPool() *SignedBeaconBlockCapella { + return vtprotoPool_SignedBeaconBlockCapella.Get().(*SignedBeaconBlockCapella) +} + +var vtprotoPool_SignedBeaconBlockCapellaV2 = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockCapellaV2{} + }, +} + +func (m *SignedBeaconBlockCapellaV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockCapellaV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockCapellaV2.Put(m) + } +} +func SignedBeaconBlockCapellaV2FromVTPool() *SignedBeaconBlockCapellaV2 { + return vtprotoPool_SignedBeaconBlockCapellaV2.Get().(*SignedBeaconBlockCapellaV2) +} + +var vtprotoPool_SignedBeaconBlockDeneb = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockDeneb{} + }, +} + +func (m *SignedBeaconBlockDeneb) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockDeneb) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockDeneb.Put(m) + } +} +func SignedBeaconBlockDenebFromVTPool() *SignedBeaconBlockDeneb { + return vtprotoPool_SignedBeaconBlockDeneb.Get().(*SignedBeaconBlockDeneb) +} + +var vtprotoPool_SignedBeaconBlockElectra = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockElectra{} + }, +} + +func (m *SignedBeaconBlockElectra) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockElectra) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockElectra.Put(m) + } +} +func SignedBeaconBlockElectraFromVTPool() *SignedBeaconBlockElectra { + return vtprotoPool_SignedBeaconBlockElectra.Get().(*SignedBeaconBlockElectra) +} + +var vtprotoPool_SignedBeaconBlockFulu = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockFulu{} + }, +} + +func (m *SignedBeaconBlockFulu) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockFulu) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockFulu.Put(m) + } +} +func SignedBeaconBlockFuluFromVTPool() *SignedBeaconBlockFulu { + return vtprotoPool_SignedBeaconBlockFulu.Get().(*SignedBeaconBlockFulu) +} + +var vtprotoPool_SignedBlindedBeaconBlockBellatrix = sync.Pool{ + New: func() interface{} { + return &SignedBlindedBeaconBlockBellatrix{} + }, +} + +func (m *SignedBlindedBeaconBlockBellatrix) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBlindedBeaconBlockBellatrix) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBlindedBeaconBlockBellatrix.Put(m) + } +} +func SignedBlindedBeaconBlockBellatrixFromVTPool() *SignedBlindedBeaconBlockBellatrix { + return vtprotoPool_SignedBlindedBeaconBlockBellatrix.Get().(*SignedBlindedBeaconBlockBellatrix) +} + +var vtprotoPool_SignedBlindedBeaconBlockBellatrixV2 = sync.Pool{ + New: func() interface{} { + return &SignedBlindedBeaconBlockBellatrixV2{} + }, +} + +func (m *SignedBlindedBeaconBlockBellatrixV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBlindedBeaconBlockBellatrixV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBlindedBeaconBlockBellatrixV2.Put(m) + } +} +func SignedBlindedBeaconBlockBellatrixV2FromVTPool() *SignedBlindedBeaconBlockBellatrixV2 { + return vtprotoPool_SignedBlindedBeaconBlockBellatrixV2.Get().(*SignedBlindedBeaconBlockBellatrixV2) +} + +var vtprotoPool_SignedBlindedBeaconBlockCapella = sync.Pool{ + New: func() interface{} { + return &SignedBlindedBeaconBlockCapella{} + }, +} + +func (m *SignedBlindedBeaconBlockCapella) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBlindedBeaconBlockCapella) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBlindedBeaconBlockCapella.Put(m) + } +} +func SignedBlindedBeaconBlockCapellaFromVTPool() *SignedBlindedBeaconBlockCapella { + return vtprotoPool_SignedBlindedBeaconBlockCapella.Get().(*SignedBlindedBeaconBlockCapella) +} + +var vtprotoPool_SignedBlindedBeaconBlockCapellaV2 = sync.Pool{ + New: func() interface{} { + return &SignedBlindedBeaconBlockCapellaV2{} + }, +} + +func (m *SignedBlindedBeaconBlockCapellaV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBlindedBeaconBlockCapellaV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBlindedBeaconBlockCapellaV2.Put(m) + } +} +func SignedBlindedBeaconBlockCapellaV2FromVTPool() *SignedBlindedBeaconBlockCapellaV2 { + return vtprotoPool_SignedBlindedBeaconBlockCapellaV2.Get().(*SignedBlindedBeaconBlockCapellaV2) +} + +var vtprotoPool_SignedBeaconBlockAltair = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockAltair{} + }, +} + +func (m *SignedBeaconBlockAltair) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockAltair) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockAltair.Put(m) + } +} +func SignedBeaconBlockAltairFromVTPool() *SignedBeaconBlockAltair { + return vtprotoPool_SignedBeaconBlockAltair.Get().(*SignedBeaconBlockAltair) +} + +var vtprotoPool_SignedBeaconBlockAltairV2 = sync.Pool{ + New: func() interface{} { + return &SignedBeaconBlockAltairV2{} + }, +} + +func (m *SignedBeaconBlockAltairV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBeaconBlockAltairV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBeaconBlockAltairV2.Put(m) + } +} +func SignedBeaconBlockAltairV2FromVTPool() *SignedBeaconBlockAltairV2 { + return vtprotoPool_SignedBeaconBlockAltairV2.Get().(*SignedBeaconBlockAltairV2) +} + +var vtprotoPool_BeaconBlockBellatrix = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBellatrix{} + }, +} + +func (m *BeaconBlockBellatrix) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockBellatrix) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBellatrix.Put(m) + } +} +func BeaconBlockBellatrixFromVTPool() *BeaconBlockBellatrix { + return vtprotoPool_BeaconBlockBellatrix.Get().(*BeaconBlockBellatrix) +} + +var vtprotoPool_BeaconBlockBellatrixV2 = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBellatrixV2{} + }, +} + +func (m *BeaconBlockBellatrixV2) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockBellatrixV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBellatrixV2.Put(m) + } +} +func BeaconBlockBellatrixV2FromVTPool() *BeaconBlockBellatrixV2 { + return vtprotoPool_BeaconBlockBellatrixV2.Get().(*BeaconBlockBellatrixV2) +} + +var vtprotoPool_BlindedBeaconBlockBellatrix = sync.Pool{ + New: func() interface{} { + return &BlindedBeaconBlockBellatrix{} + }, +} + +func (m *BlindedBeaconBlockBellatrix) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BlindedBeaconBlockBellatrix) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlindedBeaconBlockBellatrix.Put(m) + } +} +func BlindedBeaconBlockBellatrixFromVTPool() *BlindedBeaconBlockBellatrix { + return vtprotoPool_BlindedBeaconBlockBellatrix.Get().(*BlindedBeaconBlockBellatrix) +} + +var vtprotoPool_BlindedBeaconBlockBellatrixV2 = sync.Pool{ + New: func() interface{} { + return &BlindedBeaconBlockBellatrixV2{} + }, +} + +func (m *BlindedBeaconBlockBellatrixV2) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BlindedBeaconBlockBellatrixV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlindedBeaconBlockBellatrixV2.Put(m) + } +} +func BlindedBeaconBlockBellatrixV2FromVTPool() *BlindedBeaconBlockBellatrixV2 { + return vtprotoPool_BlindedBeaconBlockBellatrixV2.Get().(*BlindedBeaconBlockBellatrixV2) +} + +var vtprotoPool_BeaconBlockCapella = sync.Pool{ + New: func() interface{} { + return &BeaconBlockCapella{} + }, +} + +func (m *BeaconBlockCapella) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockCapella) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockCapella.Put(m) + } +} +func BeaconBlockCapellaFromVTPool() *BeaconBlockCapella { + return vtprotoPool_BeaconBlockCapella.Get().(*BeaconBlockCapella) +} + +var vtprotoPool_BeaconBlockCapellaV2 = sync.Pool{ + New: func() interface{} { + return &BeaconBlockCapellaV2{} + }, +} + +func (m *BeaconBlockCapellaV2) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockCapellaV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockCapellaV2.Put(m) + } +} +func BeaconBlockCapellaV2FromVTPool() *BeaconBlockCapellaV2 { + return vtprotoPool_BeaconBlockCapellaV2.Get().(*BeaconBlockCapellaV2) +} + +var vtprotoPool_BeaconBlockDeneb = sync.Pool{ + New: func() interface{} { + return &BeaconBlockDeneb{} + }, +} + +func (m *BeaconBlockDeneb) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockDeneb) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockDeneb.Put(m) + } +} +func BeaconBlockDenebFromVTPool() *BeaconBlockDeneb { + return vtprotoPool_BeaconBlockDeneb.Get().(*BeaconBlockDeneb) +} + +var vtprotoPool_BeaconBlockElectra = sync.Pool{ + New: func() interface{} { + return &BeaconBlockElectra{} + }, +} + +func (m *BeaconBlockElectra) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockElectra) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockElectra.Put(m) + } +} +func BeaconBlockElectraFromVTPool() *BeaconBlockElectra { + return vtprotoPool_BeaconBlockElectra.Get().(*BeaconBlockElectra) +} + +var vtprotoPool_BeaconBlockFulu = sync.Pool{ + New: func() interface{} { + return &BeaconBlockFulu{} + }, +} + +func (m *BeaconBlockFulu) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockFulu) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockFulu.Put(m) + } +} +func BeaconBlockFuluFromVTPool() *BeaconBlockFulu { + return vtprotoPool_BeaconBlockFulu.Get().(*BeaconBlockFulu) +} + +var vtprotoPool_BlindedBeaconBlockCapella = sync.Pool{ + New: func() interface{} { + return &BlindedBeaconBlockCapella{} + }, +} + +func (m *BlindedBeaconBlockCapella) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BlindedBeaconBlockCapella) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlindedBeaconBlockCapella.Put(m) + } +} +func BlindedBeaconBlockCapellaFromVTPool() *BlindedBeaconBlockCapella { + return vtprotoPool_BlindedBeaconBlockCapella.Get().(*BlindedBeaconBlockCapella) +} + +var vtprotoPool_BlindedBeaconBlockCapellaV2 = sync.Pool{ + New: func() interface{} { + return &BlindedBeaconBlockCapellaV2{} + }, +} + +func (m *BlindedBeaconBlockCapellaV2) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BlindedBeaconBlockCapellaV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlindedBeaconBlockCapellaV2.Put(m) + } +} +func BlindedBeaconBlockCapellaV2FromVTPool() *BlindedBeaconBlockCapellaV2 { + return vtprotoPool_BlindedBeaconBlockCapellaV2.Get().(*BlindedBeaconBlockCapellaV2) +} + +var vtprotoPool_BeaconBlockAltair = sync.Pool{ + New: func() interface{} { + return &BeaconBlockAltair{} + }, +} + +func (m *BeaconBlockAltair) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockAltair) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockAltair.Put(m) + } +} +func BeaconBlockAltairFromVTPool() *BeaconBlockAltair { + return vtprotoPool_BeaconBlockAltair.Get().(*BeaconBlockAltair) +} + +var vtprotoPool_BeaconBlockAltairV2 = sync.Pool{ + New: func() interface{} { + return &BeaconBlockAltairV2{} + }, +} + +func (m *BeaconBlockAltairV2) ResetVT() { + if m != nil { + m.Body.ReturnToVTPool() + m.Reset() + } +} +func (m *BeaconBlockAltairV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockAltairV2.Put(m) + } +} +func BeaconBlockAltairV2FromVTPool() *BeaconBlockAltairV2 { + return vtprotoPool_BeaconBlockAltairV2.Get().(*BeaconBlockAltairV2) +} + +var vtprotoPool_BeaconBlockBodyBellatrix = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyBellatrix{} + }, +} + +func (m *BeaconBlockBodyBellatrix) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayload.ReturnToVTPool() + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + } +} +func (m *BeaconBlockBodyBellatrix) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyBellatrix.Put(m) + } +} +func BeaconBlockBodyBellatrixFromVTPool() *BeaconBlockBodyBellatrix { + return vtprotoPool_BeaconBlockBodyBellatrix.Get().(*BeaconBlockBodyBellatrix) +} + +var vtprotoPool_BeaconBlockBodyBellatrixV2 = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyBellatrixV2{} + }, +} + +func (m *BeaconBlockBodyBellatrixV2) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayload.ReturnToVTPool() + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + } +} +func (m *BeaconBlockBodyBellatrixV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyBellatrixV2.Put(m) + } +} +func BeaconBlockBodyBellatrixV2FromVTPool() *BeaconBlockBodyBellatrixV2 { + return vtprotoPool_BeaconBlockBodyBellatrixV2.Get().(*BeaconBlockBodyBellatrixV2) +} + +var vtprotoPool_BlindedBeaconBlockBodyBellatrix = sync.Pool{ + New: func() interface{} { + return &BlindedBeaconBlockBodyBellatrix{} + }, +} + +func (m *BlindedBeaconBlockBodyBellatrix) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayloadHeader.ReturnToVTPool() + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + } +} +func (m *BlindedBeaconBlockBodyBellatrix) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlindedBeaconBlockBodyBellatrix.Put(m) + } +} +func BlindedBeaconBlockBodyBellatrixFromVTPool() *BlindedBeaconBlockBodyBellatrix { + return vtprotoPool_BlindedBeaconBlockBodyBellatrix.Get().(*BlindedBeaconBlockBodyBellatrix) +} + +var vtprotoPool_BlindedBeaconBlockBodyBellatrixV2 = sync.Pool{ + New: func() interface{} { + return &BlindedBeaconBlockBodyBellatrixV2{} + }, +} + +func (m *BlindedBeaconBlockBodyBellatrixV2) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayloadHeader.ReturnToVTPool() + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + } +} +func (m *BlindedBeaconBlockBodyBellatrixV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlindedBeaconBlockBodyBellatrixV2.Put(m) + } +} +func BlindedBeaconBlockBodyBellatrixV2FromVTPool() *BlindedBeaconBlockBodyBellatrixV2 { + return vtprotoPool_BlindedBeaconBlockBodyBellatrixV2.Get().(*BlindedBeaconBlockBodyBellatrixV2) +} + +var vtprotoPool_BeaconBlockBodyCapella = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyCapella{} + }, +} + +func (m *BeaconBlockBodyCapella) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayload.ReturnToVTPool() + for _, mm := range m.BlsToExecutionChanges { + mm.ResetVT() + } + f5 := m.BlsToExecutionChanges[:0] + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + m.BlsToExecutionChanges = f5 + } +} +func (m *BeaconBlockBodyCapella) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyCapella.Put(m) + } +} +func BeaconBlockBodyCapellaFromVTPool() *BeaconBlockBodyCapella { + return vtprotoPool_BeaconBlockBodyCapella.Get().(*BeaconBlockBodyCapella) +} + +var vtprotoPool_BeaconBlockBodyCapellaV2 = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyCapellaV2{} + }, +} + +func (m *BeaconBlockBodyCapellaV2) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayload.ReturnToVTPool() + for _, mm := range m.BlsToExecutionChanges { + mm.ResetVT() + } + f5 := m.BlsToExecutionChanges[:0] + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + m.BlsToExecutionChanges = f5 + } +} +func (m *BeaconBlockBodyCapellaV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyCapellaV2.Put(m) + } +} +func BeaconBlockBodyCapellaV2FromVTPool() *BeaconBlockBodyCapellaV2 { + return vtprotoPool_BeaconBlockBodyCapellaV2.Get().(*BeaconBlockBodyCapellaV2) +} + +var vtprotoPool_BeaconBlockBodyDeneb = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyDeneb{} + }, +} + +func (m *BeaconBlockBodyDeneb) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayload.ReturnToVTPool() + for _, mm := range m.BlsToExecutionChanges { + mm.ResetVT() + } + f5 := m.BlsToExecutionChanges[:0] + f6 := m.BlobKzgCommitments[:0] + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + m.BlsToExecutionChanges = f5 + m.BlobKzgCommitments = f6 + } +} +func (m *BeaconBlockBodyDeneb) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyDeneb.Put(m) + } +} +func BeaconBlockBodyDenebFromVTPool() *BeaconBlockBodyDeneb { + return vtprotoPool_BeaconBlockBodyDeneb.Get().(*BeaconBlockBodyDeneb) +} + +var vtprotoPool_BeaconBlockBodyElectra = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyElectra{} + }, +} + +func (m *BeaconBlockBodyElectra) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayload.ReturnToVTPool() + for _, mm := range m.BlsToExecutionChanges { + mm.ResetVT() + } + f5 := m.BlsToExecutionChanges[:0] + f6 := m.BlobKzgCommitments[:0] + m.ExecutionRequests.ReturnToVTPool() + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + m.BlsToExecutionChanges = f5 + m.BlobKzgCommitments = f6 + } +} +func (m *BeaconBlockBodyElectra) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyElectra.Put(m) + } +} +func BeaconBlockBodyElectraFromVTPool() *BeaconBlockBodyElectra { + return vtprotoPool_BeaconBlockBodyElectra.Get().(*BeaconBlockBodyElectra) +} + +var vtprotoPool_BeaconBlockBodyFulu = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyFulu{} + }, +} + +func (m *BeaconBlockBodyFulu) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayload.ReturnToVTPool() + for _, mm := range m.BlsToExecutionChanges { + mm.ResetVT() + } + f5 := m.BlsToExecutionChanges[:0] + f6 := m.BlobKzgCommitments[:0] + m.ExecutionRequests.ReturnToVTPool() + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + m.BlsToExecutionChanges = f5 + m.BlobKzgCommitments = f6 + } +} +func (m *BeaconBlockBodyFulu) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyFulu.Put(m) + } +} +func BeaconBlockBodyFuluFromVTPool() *BeaconBlockBodyFulu { + return vtprotoPool_BeaconBlockBodyFulu.Get().(*BeaconBlockBodyFulu) +} + +var vtprotoPool_BlindedBeaconBlockBodyCapella = sync.Pool{ + New: func() interface{} { + return &BlindedBeaconBlockBodyCapella{} + }, +} + +func (m *BlindedBeaconBlockBodyCapella) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayloadHeader.ReturnToVTPool() + for _, mm := range m.BlsToExecutionChanges { + mm.ResetVT() + } + f5 := m.BlsToExecutionChanges[:0] + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + m.BlsToExecutionChanges = f5 + } +} +func (m *BlindedBeaconBlockBodyCapella) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlindedBeaconBlockBodyCapella.Put(m) + } +} +func BlindedBeaconBlockBodyCapellaFromVTPool() *BlindedBeaconBlockBodyCapella { + return vtprotoPool_BlindedBeaconBlockBodyCapella.Get().(*BlindedBeaconBlockBodyCapella) +} + +var vtprotoPool_BlindedBeaconBlockBodyCapellaV2 = sync.Pool{ + New: func() interface{} { + return &BlindedBeaconBlockBodyCapellaV2{} + }, +} + +func (m *BlindedBeaconBlockBodyCapellaV2) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.ExecutionPayloadHeader.ReturnToVTPool() + for _, mm := range m.BlsToExecutionChanges { + mm.ResetVT() + } + f5 := m.BlsToExecutionChanges[:0] + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + m.BlsToExecutionChanges = f5 + } +} +func (m *BlindedBeaconBlockBodyCapellaV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlindedBeaconBlockBodyCapellaV2.Put(m) + } +} +func BlindedBeaconBlockBodyCapellaV2FromVTPool() *BlindedBeaconBlockBodyCapellaV2 { + return vtprotoPool_BlindedBeaconBlockBodyCapellaV2.Get().(*BlindedBeaconBlockBodyCapellaV2) +} + +var vtprotoPool_BeaconBlockBodyAltair = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyAltair{} + }, +} + +func (m *BeaconBlockBodyAltair) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + } +} +func (m *BeaconBlockBodyAltair) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyAltair.Put(m) + } +} +func BeaconBlockBodyAltairFromVTPool() *BeaconBlockBodyAltair { + return vtprotoPool_BeaconBlockBodyAltair.Get().(*BeaconBlockBodyAltair) +} + +var vtprotoPool_BeaconBlockBodyAltairV2 = sync.Pool{ + New: func() interface{} { + return &BeaconBlockBodyAltairV2{} + }, +} + +func (m *BeaconBlockBodyAltairV2) ResetVT() { + if m != nil { + m.Eth1Data.ReturnToVTPool() + for _, mm := range m.ProposerSlashings { + mm.ResetVT() + } + f0 := m.ProposerSlashings[:0] + for _, mm := range m.AttesterSlashings { + mm.ResetVT() + } + f1 := m.AttesterSlashings[:0] + for _, mm := range m.Attestations { + mm.ResetVT() + } + f2 := m.Attestations[:0] + for _, mm := range m.Deposits { + mm.ResetVT() + } + f3 := m.Deposits[:0] + for _, mm := range m.VoluntaryExits { + mm.ResetVT() + } + f4 := m.VoluntaryExits[:0] + m.SyncAggregate.ReturnToVTPool() + m.Reset() + m.ProposerSlashings = f0 + m.AttesterSlashings = f1 + m.Attestations = f2 + m.Deposits = f3 + m.VoluntaryExits = f4 + } +} +func (m *BeaconBlockBodyAltairV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlockBodyAltairV2.Put(m) + } +} +func BeaconBlockBodyAltairV2FromVTPool() *BeaconBlockBodyAltairV2 { + return vtprotoPool_BeaconBlockBodyAltairV2.Get().(*BeaconBlockBodyAltairV2) +} +func (m *SignedBeaconBlockBellatrix) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockBellatrixV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockCapella) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockCapellaV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockDeneb) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockElectra) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockFulu) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBlindedBeaconBlockBellatrix) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBlindedBeaconBlockBellatrixV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBlindedBeaconBlockCapella) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBlindedBeaconBlockCapellaV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockAltair) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockAltairV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBellatrix) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.ProposerIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProposerIndex)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBellatrixV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlindedBeaconBlockBellatrix) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.ProposerIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProposerIndex)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlindedBeaconBlockBellatrixV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockCapella) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.ProposerIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProposerIndex)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockCapellaV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockDeneb) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockElectra) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockFulu) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlindedBeaconBlockCapella) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.ProposerIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProposerIndex)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlindedBeaconBlockCapellaV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockAltair) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Slot)) + } + if m.ProposerIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProposerIndex)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockAltairV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Body != nil { + l = m.Body.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyBellatrix) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayload != nil { + l = m.ExecutionPayload.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyBellatrixV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayload != nil { + l = m.ExecutionPayload.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlindedBeaconBlockBodyBellatrix) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayloadHeader != nil { + l = m.ExecutionPayloadHeader.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlindedBeaconBlockBodyBellatrixV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayloadHeader != nil { + l = m.ExecutionPayloadHeader.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyCapella) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayload != nil { + l = m.ExecutionPayload.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlsToExecutionChanges) > 0 { + for _, e := range m.BlsToExecutionChanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyCapellaV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayload != nil { + l = m.ExecutionPayload.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlsToExecutionChanges) > 0 { + for _, e := range m.BlsToExecutionChanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyDeneb) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayload != nil { + l = m.ExecutionPayload.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlsToExecutionChanges) > 0 { + for _, e := range m.BlsToExecutionChanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.BlobKzgCommitments) > 0 { + for _, s := range m.BlobKzgCommitments { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyElectra) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayload != nil { + l = m.ExecutionPayload.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlsToExecutionChanges) > 0 { + for _, e := range m.BlsToExecutionChanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.BlobKzgCommitments) > 0 { + for _, s := range m.BlobKzgCommitments { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ExecutionRequests != nil { + l = m.ExecutionRequests.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyFulu) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayload != nil { + l = m.ExecutionPayload.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlsToExecutionChanges) > 0 { + for _, e := range m.BlsToExecutionChanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.BlobKzgCommitments) > 0 { + for _, s := range m.BlobKzgCommitments { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ExecutionRequests != nil { + l = m.ExecutionRequests.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlindedBeaconBlockBodyCapella) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayloadHeader != nil { + l = m.ExecutionPayloadHeader.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlsToExecutionChanges) > 0 { + for _, e := range m.BlsToExecutionChanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *BlindedBeaconBlockBodyCapellaV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionPayloadHeader != nil { + l = m.ExecutionPayloadHeader.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlsToExecutionChanges) > 0 { + for _, e := range m.BlsToExecutionChanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyAltair) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlockBodyAltairV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RandaoReveal) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Eth1Data != nil { + l = m.Eth1Data.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Graffiti) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ProposerSlashings) > 0 { + for _, e := range m.ProposerSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.AttesterSlashings) > 0 { + for _, e := range m.AttesterSlashings { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Attestations) > 0 { + for _, e := range m.Attestations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Deposits) > 0 { + for _, e := range m.Deposits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.VoluntaryExits) > 0 { + for _, e := range m.VoluntaryExits { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.SyncAggregate != nil { + l = m.SyncAggregate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBeaconBlockBellatrix) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockBellatrix: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockBellatrix: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockBellatrixFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockBellatrixV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockBellatrixV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockBellatrixV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockBellatrixV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockCapella) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockCapella: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockCapella: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockCapellaFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockCapellaV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockCapellaV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockCapellaV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockCapellaV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockDeneb) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockDeneb: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockDeneb: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockDenebFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockElectra) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockElectra: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockElectra: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockElectraFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockFulu) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockFulu: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockFulu: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockFuluFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBlindedBeaconBlockBellatrix) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBlindedBeaconBlockBellatrix: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBlindedBeaconBlockBellatrix: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BlindedBeaconBlockBellatrixFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBlindedBeaconBlockBellatrixV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBlindedBeaconBlockBellatrixV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBlindedBeaconBlockBellatrixV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BlindedBeaconBlockBellatrixV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBlindedBeaconBlockCapella) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBlindedBeaconBlockCapella: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBlindedBeaconBlockCapella: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BlindedBeaconBlockCapellaFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBlindedBeaconBlockCapellaV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBlindedBeaconBlockCapellaV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBlindedBeaconBlockCapellaV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BlindedBeaconBlockCapellaV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockAltair) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockAltair: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockAltair: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockAltairFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBeaconBlockAltairV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBeaconBlockAltairV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBeaconBlockAltairV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BeaconBlockAltairV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBellatrix) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBellatrix: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBellatrix: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + m.ProposerIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposerIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyBellatrixFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBellatrixV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBellatrixV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBellatrixV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyBellatrixV2FromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlindedBeaconBlockBellatrix) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlindedBeaconBlockBellatrix: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlindedBeaconBlockBellatrix: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + m.ProposerIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposerIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BlindedBeaconBlockBodyBellatrixFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlindedBeaconBlockBellatrixV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlindedBeaconBlockBellatrixV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlindedBeaconBlockBellatrixV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BlindedBeaconBlockBodyBellatrixV2FromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockCapella) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockCapella: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockCapella: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + m.ProposerIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposerIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyCapellaFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockCapellaV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockCapellaV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockCapellaV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyCapellaV2FromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockDeneb) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockDeneb: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockDeneb: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyDenebFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockElectra) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockElectra: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockElectra: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyElectraFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockFulu) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockFulu: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockFulu: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyFuluFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlindedBeaconBlockCapella) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlindedBeaconBlockCapella: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlindedBeaconBlockCapella: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + m.ProposerIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposerIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BlindedBeaconBlockBodyCapellaFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlindedBeaconBlockCapellaV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlindedBeaconBlockCapellaV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlindedBeaconBlockCapellaV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BlindedBeaconBlockBodyCapellaV2FromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockAltair) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockAltair: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockAltair: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + m.ProposerIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposerIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyAltairFromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockAltairV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockAltairV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockAltairV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Body == nil { + m.Body = BeaconBlockBodyAltairV2FromVTPool() + } + if err := m.Body.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyBellatrix) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyBellatrix: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyBellatrix: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayload == nil { + m.ExecutionPayload = v1.ExecutionPayloadFromVTPool() + } + if err := m.ExecutionPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyBellatrixV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyBellatrixV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyBellatrixV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayload == nil { + m.ExecutionPayload = v1.ExecutionPayloadV2FromVTPool() + } + if err := m.ExecutionPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlindedBeaconBlockBodyBellatrix) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlindedBeaconBlockBodyBellatrix: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlindedBeaconBlockBodyBellatrix: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayloadHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayloadHeader == nil { + m.ExecutionPayloadHeader = v1.ExecutionPayloadHeaderFromVTPool() + } + if err := m.ExecutionPayloadHeader.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlindedBeaconBlockBodyBellatrixV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlindedBeaconBlockBodyBellatrixV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlindedBeaconBlockBodyBellatrixV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayloadHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayloadHeader == nil { + m.ExecutionPayloadHeader = v1.ExecutionPayloadHeaderV2FromVTPool() + } + if err := m.ExecutionPayloadHeader.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyCapella) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyCapella: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyCapella: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayload == nil { + m.ExecutionPayload = v1.ExecutionPayloadCapellaFromVTPool() + } + if err := m.ExecutionPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlsToExecutionChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.BlsToExecutionChanges) == cap(m.BlsToExecutionChanges) { + m.BlsToExecutionChanges = append(m.BlsToExecutionChanges, &SignedBLSToExecutionChange{}) + } else { + m.BlsToExecutionChanges = m.BlsToExecutionChanges[:len(m.BlsToExecutionChanges)+1] + if m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] == nil { + m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] = &SignedBLSToExecutionChange{} + } + } + if err := m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyCapellaV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyCapellaV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyCapellaV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayload == nil { + m.ExecutionPayload = v1.ExecutionPayloadCapellaV2FromVTPool() + } + if err := m.ExecutionPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlsToExecutionChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.BlsToExecutionChanges) == cap(m.BlsToExecutionChanges) { + m.BlsToExecutionChanges = append(m.BlsToExecutionChanges, &SignedBLSToExecutionChange{}) + } else { + m.BlsToExecutionChanges = m.BlsToExecutionChanges[:len(m.BlsToExecutionChanges)+1] + if m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] == nil { + m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] = &SignedBLSToExecutionChange{} + } + } + if err := m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyDeneb) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyDeneb: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyDeneb: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayload == nil { + m.ExecutionPayload = v1.ExecutionPayloadDenebFromVTPool() + } + if err := m.ExecutionPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlsToExecutionChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.BlsToExecutionChanges) == cap(m.BlsToExecutionChanges) { + m.BlsToExecutionChanges = append(m.BlsToExecutionChanges, &SignedBLSToExecutionChange{}) + } else { + m.BlsToExecutionChanges = m.BlsToExecutionChanges[:len(m.BlsToExecutionChanges)+1] + if m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] == nil { + m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] = &SignedBLSToExecutionChange{} + } + } + if err := m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobKzgCommitments", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobKzgCommitments = append(m.BlobKzgCommitments, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyElectra) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyElectra: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyElectra: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayload == nil { + m.ExecutionPayload = v1.ExecutionPayloadElectraFromVTPool() + } + if err := m.ExecutionPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlsToExecutionChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.BlsToExecutionChanges) == cap(m.BlsToExecutionChanges) { + m.BlsToExecutionChanges = append(m.BlsToExecutionChanges, &SignedBLSToExecutionChange{}) + } else { + m.BlsToExecutionChanges = m.BlsToExecutionChanges[:len(m.BlsToExecutionChanges)+1] + if m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] == nil { + m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] = &SignedBLSToExecutionChange{} + } + } + if err := m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobKzgCommitments", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobKzgCommitments = append(m.BlobKzgCommitments, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionRequests", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionRequests == nil { + m.ExecutionRequests = v1.ElectraExecutionRequestsFromVTPool() + } + if err := m.ExecutionRequests.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyFulu) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyFulu: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyFulu: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayload == nil { + m.ExecutionPayload = v1.ExecutionPayloadElectraFromVTPool() + } + if err := m.ExecutionPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlsToExecutionChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.BlsToExecutionChanges) == cap(m.BlsToExecutionChanges) { + m.BlsToExecutionChanges = append(m.BlsToExecutionChanges, &SignedBLSToExecutionChange{}) + } else { + m.BlsToExecutionChanges = m.BlsToExecutionChanges[:len(m.BlsToExecutionChanges)+1] + if m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] == nil { + m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] = &SignedBLSToExecutionChange{} + } + } + if err := m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobKzgCommitments", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobKzgCommitments = append(m.BlobKzgCommitments, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionRequests", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionRequests == nil { + m.ExecutionRequests = v1.ElectraExecutionRequestsFromVTPool() + } + if err := m.ExecutionRequests.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlindedBeaconBlockBodyCapella) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlindedBeaconBlockBodyCapella: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlindedBeaconBlockBodyCapella: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayloadHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayloadHeader == nil { + m.ExecutionPayloadHeader = v1.ExecutionPayloadHeaderCapellaFromVTPool() + } + if err := m.ExecutionPayloadHeader.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlsToExecutionChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.BlsToExecutionChanges) == cap(m.BlsToExecutionChanges) { + m.BlsToExecutionChanges = append(m.BlsToExecutionChanges, &SignedBLSToExecutionChange{}) + } else { + m.BlsToExecutionChanges = m.BlsToExecutionChanges[:len(m.BlsToExecutionChanges)+1] + if m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] == nil { + m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] = &SignedBLSToExecutionChange{} + } + } + if err := m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlindedBeaconBlockBodyCapellaV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlindedBeaconBlockBodyCapellaV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlindedBeaconBlockBodyCapellaV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionPayloadHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionPayloadHeader == nil { + m.ExecutionPayloadHeader = v1.ExecutionPayloadHeaderCapellaV2FromVTPool() + } + if err := m.ExecutionPayloadHeader.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlsToExecutionChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.BlsToExecutionChanges) == cap(m.BlsToExecutionChanges) { + m.BlsToExecutionChanges = append(m.BlsToExecutionChanges, &SignedBLSToExecutionChange{}) + } else { + m.BlsToExecutionChanges = m.BlsToExecutionChanges[:len(m.BlsToExecutionChanges)+1] + if m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] == nil { + m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1] = &SignedBLSToExecutionChange{} + } + } + if err := m.BlsToExecutionChanges[len(m.BlsToExecutionChanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyAltair) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyAltair: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyAltair: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BeaconBlockBodyAltairV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlockBodyAltairV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlockBodyAltairV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RandaoReveal = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth1Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Eth1Data == nil { + m.Eth1Data = v1.Eth1DataFromVTPool() + } + if err := m.Eth1Data.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Graffiti = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ProposerSlashings) == cap(m.ProposerSlashings) { + m.ProposerSlashings = append(m.ProposerSlashings, &v1.ProposerSlashing{}) + } else { + m.ProposerSlashings = m.ProposerSlashings[:len(m.ProposerSlashings)+1] + if m.ProposerSlashings[len(m.ProposerSlashings)-1] == nil { + m.ProposerSlashings[len(m.ProposerSlashings)-1] = &v1.ProposerSlashing{} + } + } + if err := m.ProposerSlashings[len(m.ProposerSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.AttesterSlashings) == cap(m.AttesterSlashings) { + m.AttesterSlashings = append(m.AttesterSlashings, &v1.AttesterSlashing{}) + } else { + m.AttesterSlashings = m.AttesterSlashings[:len(m.AttesterSlashings)+1] + if m.AttesterSlashings[len(m.AttesterSlashings)-1] == nil { + m.AttesterSlashings[len(m.AttesterSlashings)-1] = &v1.AttesterSlashing{} + } + } + if err := m.AttesterSlashings[len(m.AttesterSlashings)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Attestations) == cap(m.Attestations) { + m.Attestations = append(m.Attestations, &v1.Attestation{}) + } else { + m.Attestations = m.Attestations[:len(m.Attestations)+1] + if m.Attestations[len(m.Attestations)-1] == nil { + m.Attestations[len(m.Attestations)-1] = &v1.Attestation{} + } + } + if err := m.Attestations[len(m.Attestations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deposits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Deposits) == cap(m.Deposits) { + m.Deposits = append(m.Deposits, &v1.Deposit{}) + } else { + m.Deposits = m.Deposits[:len(m.Deposits)+1] + if m.Deposits[len(m.Deposits)-1] == nil { + m.Deposits[len(m.Deposits)-1] = &v1.Deposit{} + } + } + if err := m.Deposits[len(m.Deposits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VoluntaryExits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.VoluntaryExits) == cap(m.VoluntaryExits) { + m.VoluntaryExits = append(m.VoluntaryExits, &v1.SignedVoluntaryExit{}) + } else { + m.VoluntaryExits = m.VoluntaryExits[:len(m.VoluntaryExits)+1] + if m.VoluntaryExits[len(m.VoluntaryExits)-1] == nil { + m.VoluntaryExits[len(m.VoluntaryExits)-1] = &v1.SignedVoluntaryExit{} + } + } + if err := m.VoluntaryExits[len(m.VoluntaryExits)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncAggregate == nil { + m.SyncAggregate = v1.SyncAggregateFromVTPool() + } + if err := m.SyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v2/events_vtproto.pb.go b/pkg/proto/eth/v2/events_vtproto.pb.go new file mode 100644 index 000000000..a693a63fb --- /dev/null +++ b/pkg/proto/eth/v2/events_vtproto.pb.go @@ -0,0 +1,1466 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v2/events.proto + +package v2 + +import ( + fmt "fmt" + v1 "github.com/ethpandaops/xatu/pkg/proto/eth/v1" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *EventBlock) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Message.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if m.Version != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x30 + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} + +func (m *EventBlock_Phase0Block) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock_Phase0Block) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Phase0Block != nil { + size, err := m.Phase0Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *EventBlock_AltairBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock_AltairBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.AltairBlock != nil { + size, err := m.AltairBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *EventBlock_BellatrixBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock_BellatrixBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BellatrixBlock != nil { + size, err := m.BellatrixBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *EventBlock_CapellaBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock_CapellaBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.CapellaBlock != nil { + size, err := m.CapellaBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *EventBlock_DenebBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock_DenebBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.DenebBlock != nil { + size, err := m.DenebBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + return len(dAtA) - i, nil +} +func (m *EventBlock_ElectraBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock_ElectraBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ElectraBlock != nil { + size, err := m.ElectraBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + return len(dAtA) - i, nil +} +func (m *EventBlock_FuluBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlock_FuluBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FuluBlock != nil { + size, err := m.FuluBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + return len(dAtA) - i, nil +} +func (m *EventBlockV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventBlockV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Message.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if m.Version != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x30 + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} + +func (m *EventBlockV2_Phase0Block) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2_Phase0Block) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Phase0Block != nil { + size, err := m.Phase0Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *EventBlockV2_AltairBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2_AltairBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.AltairBlock != nil { + size, err := m.AltairBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *EventBlockV2_BellatrixBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2_BellatrixBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BellatrixBlock != nil { + size, err := m.BellatrixBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *EventBlockV2_CapellaBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2_CapellaBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.CapellaBlock != nil { + size, err := m.CapellaBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *EventBlockV2_DenebBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2_DenebBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.DenebBlock != nil { + size, err := m.DenebBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + return len(dAtA) - i, nil +} +func (m *EventBlockV2_ElectraBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2_ElectraBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ElectraBlock != nil { + size, err := m.ElectraBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + return len(dAtA) - i, nil +} +func (m *EventBlockV2_FuluBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EventBlockV2_FuluBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FuluBlock != nil { + size, err := m.FuluBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + return len(dAtA) - i, nil +} + +var vtprotoPool_EventBlock = sync.Pool{ + New: func() interface{} { + return &EventBlock{} + }, +} + +func (m *EventBlock) ResetVT() { + if m != nil { + if oneof, ok := m.Message.(*EventBlock_Phase0Block); ok { + oneof.Phase0Block.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlock_AltairBlock); ok { + oneof.AltairBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlock_BellatrixBlock); ok { + oneof.BellatrixBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlock_CapellaBlock); ok { + oneof.CapellaBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlock_DenebBlock); ok { + oneof.DenebBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlock_ElectraBlock); ok { + oneof.ElectraBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlock_FuluBlock); ok { + oneof.FuluBlock.ReturnToVTPool() + } + m.Reset() + } +} +func (m *EventBlock) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventBlock.Put(m) + } +} +func EventBlockFromVTPool() *EventBlock { + return vtprotoPool_EventBlock.Get().(*EventBlock) +} + +var vtprotoPool_EventBlockV2 = sync.Pool{ + New: func() interface{} { + return &EventBlockV2{} + }, +} + +func (m *EventBlockV2) ResetVT() { + if m != nil { + if oneof, ok := m.Message.(*EventBlockV2_Phase0Block); ok { + oneof.Phase0Block.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlockV2_AltairBlock); ok { + oneof.AltairBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlockV2_BellatrixBlock); ok { + oneof.BellatrixBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlockV2_CapellaBlock); ok { + oneof.CapellaBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlockV2_DenebBlock); ok { + oneof.DenebBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlockV2_ElectraBlock); ok { + oneof.ElectraBlock.ReturnToVTPool() + } + if oneof, ok := m.Message.(*EventBlockV2_FuluBlock); ok { + oneof.FuluBlock.ReturnToVTPool() + } + m.Reset() + } +} +func (m *EventBlockV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EventBlockV2.Put(m) + } +} +func EventBlockV2FromVTPool() *EventBlockV2 { + return vtprotoPool_EventBlockV2.Get().(*EventBlockV2) +} +func (m *EventBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if vtmsg, ok := m.Message.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Version != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Version)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventBlock_Phase0Block) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Phase0Block != nil { + l = m.Phase0Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlock_AltairBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AltairBlock != nil { + l = m.AltairBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlock_BellatrixBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BellatrixBlock != nil { + l = m.BellatrixBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlock_CapellaBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CapellaBlock != nil { + l = m.CapellaBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlock_DenebBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DenebBlock != nil { + l = m.DenebBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlock_ElectraBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ElectraBlock != nil { + l = m.ElectraBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlock_FuluBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FuluBlock != nil { + l = m.FuluBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlockV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if vtmsg, ok := m.Message.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Version != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Version)) + } + n += len(m.unknownFields) + return n +} + +func (m *EventBlockV2_Phase0Block) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Phase0Block != nil { + l = m.Phase0Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlockV2_AltairBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AltairBlock != nil { + l = m.AltairBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlockV2_BellatrixBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BellatrixBlock != nil { + l = m.BellatrixBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlockV2_CapellaBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CapellaBlock != nil { + l = m.CapellaBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlockV2_DenebBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DenebBlock != nil { + l = m.DenebBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlockV2_ElectraBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ElectraBlock != nil { + l = m.ElectraBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlockV2_FuluBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FuluBlock != nil { + l = m.FuluBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *EventBlock) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase0Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlock_Phase0Block); ok { + if err := oneof.Phase0Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.BeaconBlockFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlock_Phase0Block{Phase0Block: v} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AltairBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlock_AltairBlock); ok { + if err := oneof.AltairBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockAltairFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlock_AltairBlock{AltairBlock: v} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BellatrixBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlock_BellatrixBlock); ok { + if err := oneof.BellatrixBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockBellatrixFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlock_BellatrixBlock{BellatrixBlock: v} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CapellaBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlock_CapellaBlock); ok { + if err := oneof.CapellaBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockCapellaFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlock_CapellaBlock{CapellaBlock: v} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= BlockVersion(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DenebBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlock_DenebBlock); ok { + if err := oneof.DenebBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockDenebFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlock_DenebBlock{DenebBlock: v} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ElectraBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlock_ElectraBlock); ok { + if err := oneof.ElectraBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockElectraFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlock_ElectraBlock{ElectraBlock: v} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FuluBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlock_FuluBlock); ok { + if err := oneof.FuluBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockFuluFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlock_FuluBlock{FuluBlock: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventBlockV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventBlockV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBlockV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase0Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlockV2_Phase0Block); ok { + if err := oneof.Phase0Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.BeaconBlockV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlockV2_Phase0Block{Phase0Block: v} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AltairBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlockV2_AltairBlock); ok { + if err := oneof.AltairBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockAltairV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlockV2_AltairBlock{AltairBlock: v} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BellatrixBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlockV2_BellatrixBlock); ok { + if err := oneof.BellatrixBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockBellatrixV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlockV2_BellatrixBlock{BellatrixBlock: v} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CapellaBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlockV2_CapellaBlock); ok { + if err := oneof.CapellaBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockCapellaV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlockV2_CapellaBlock{CapellaBlock: v} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= BlockVersion(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DenebBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlockV2_DenebBlock); ok { + if err := oneof.DenebBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockDenebFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlockV2_DenebBlock{DenebBlock: v} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ElectraBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlockV2_ElectraBlock); ok { + if err := oneof.ElectraBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockElectraFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlockV2_ElectraBlock{ElectraBlock: v} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FuluBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*EventBlockV2_FuluBlock); ok { + if err := oneof.FuluBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := BeaconBlockFuluFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &EventBlockV2_FuluBlock{FuluBlock: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/eth/v2/withdrawals_vtproto.pb.go b/pkg/proto/eth/v2/withdrawals_vtproto.pb.go new file mode 100644 index 000000000..1221cb17f --- /dev/null +++ b/pkg/proto/eth/v2/withdrawals_vtproto.pb.go @@ -0,0 +1,1098 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/eth/v2/withdrawals.proto + +package v2 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *BLSToExecutionChange) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BLSToExecutionChange) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BLSToExecutionChange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ToExecutionAddress) > 0 { + i -= len(m.ToExecutionAddress) + copy(dAtA[i:], m.ToExecutionAddress) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ToExecutionAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.FromBlsPubkey) > 0 { + i -= len(m.FromBlsPubkey) + copy(dAtA[i:], m.FromBlsPubkey) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FromBlsPubkey))) + i-- + dAtA[i] = 0x12 + } + if m.ValidatorIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ValidatorIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BLSToExecutionChangeV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BLSToExecutionChangeV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BLSToExecutionChangeV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ToExecutionAddress) > 0 { + i -= len(m.ToExecutionAddress) + copy(dAtA[i:], m.ToExecutionAddress) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ToExecutionAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.FromBlsPubkey) > 0 { + i -= len(m.FromBlsPubkey) + copy(dAtA[i:], m.FromBlsPubkey) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FromBlsPubkey))) + i-- + dAtA[i] = 0x12 + } + if m.ValidatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBLSToExecutionChange) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBLSToExecutionChange) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBLSToExecutionChange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SignedBLSToExecutionChangeV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SignedBLSToExecutionChangeV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SignedBLSToExecutionChangeV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SubmitBLSToExecutionChangesRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SubmitBLSToExecutionChangesRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SubmitBLSToExecutionChangesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Changes) > 0 { + for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Changes[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +var vtprotoPool_BLSToExecutionChange = sync.Pool{ + New: func() interface{} { + return &BLSToExecutionChange{} + }, +} + +func (m *BLSToExecutionChange) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BLSToExecutionChange) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BLSToExecutionChange.Put(m) + } +} +func BLSToExecutionChangeFromVTPool() *BLSToExecutionChange { + return vtprotoPool_BLSToExecutionChange.Get().(*BLSToExecutionChange) +} + +var vtprotoPool_BLSToExecutionChangeV2 = sync.Pool{ + New: func() interface{} { + return &BLSToExecutionChangeV2{} + }, +} + +func (m *BLSToExecutionChangeV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BLSToExecutionChangeV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BLSToExecutionChangeV2.Put(m) + } +} +func BLSToExecutionChangeV2FromVTPool() *BLSToExecutionChangeV2 { + return vtprotoPool_BLSToExecutionChangeV2.Get().(*BLSToExecutionChangeV2) +} + +var vtprotoPool_SignedBLSToExecutionChange = sync.Pool{ + New: func() interface{} { + return &SignedBLSToExecutionChange{} + }, +} + +func (m *SignedBLSToExecutionChange) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBLSToExecutionChange) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBLSToExecutionChange.Put(m) + } +} +func SignedBLSToExecutionChangeFromVTPool() *SignedBLSToExecutionChange { + return vtprotoPool_SignedBLSToExecutionChange.Get().(*SignedBLSToExecutionChange) +} + +var vtprotoPool_SignedBLSToExecutionChangeV2 = sync.Pool{ + New: func() interface{} { + return &SignedBLSToExecutionChangeV2{} + }, +} + +func (m *SignedBLSToExecutionChangeV2) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *SignedBLSToExecutionChangeV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SignedBLSToExecutionChangeV2.Put(m) + } +} +func SignedBLSToExecutionChangeV2FromVTPool() *SignedBLSToExecutionChangeV2 { + return vtprotoPool_SignedBLSToExecutionChangeV2.Get().(*SignedBLSToExecutionChangeV2) +} + +var vtprotoPool_SubmitBLSToExecutionChangesRequest = sync.Pool{ + New: func() interface{} { + return &SubmitBLSToExecutionChangesRequest{} + }, +} + +func (m *SubmitBLSToExecutionChangesRequest) ResetVT() { + if m != nil { + for _, mm := range m.Changes { + mm.ResetVT() + } + f0 := m.Changes[:0] + m.Reset() + m.Changes = f0 + } +} +func (m *SubmitBLSToExecutionChangesRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SubmitBLSToExecutionChangesRequest.Put(m) + } +} +func SubmitBLSToExecutionChangesRequestFromVTPool() *SubmitBLSToExecutionChangesRequest { + return vtprotoPool_SubmitBLSToExecutionChangesRequest.Get().(*SubmitBLSToExecutionChangesRequest) +} +func (m *BLSToExecutionChange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ValidatorIndex)) + } + l = len(m.FromBlsPubkey) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ToExecutionAddress) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BLSToExecutionChangeV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ValidatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FromBlsPubkey) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ToExecutionAddress) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBLSToExecutionChange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SignedBLSToExecutionChangeV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SubmitBLSToExecutionChangesRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Changes) > 0 { + for _, e := range m.Changes { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *BLSToExecutionChange) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BLSToExecutionChange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BLSToExecutionChange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + m.ValidatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FromBlsPubkey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FromBlsPubkey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ToExecutionAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ToExecutionAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BLSToExecutionChangeV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BLSToExecutionChangeV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BLSToExecutionChangeV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorIndex == nil { + m.ValidatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FromBlsPubkey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FromBlsPubkey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ToExecutionAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ToExecutionAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBLSToExecutionChange) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBLSToExecutionChange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBLSToExecutionChange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BLSToExecutionChangeFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SignedBLSToExecutionChangeV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignedBLSToExecutionChangeV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignedBLSToExecutionChangeV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = BLSToExecutionChangeV2FromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SubmitBLSToExecutionChangesRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SubmitBLSToExecutionChangesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SubmitBLSToExecutionChangesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Changes) == cap(m.Changes) { + m.Changes = append(m.Changes, &SignedBLSToExecutionChange{}) + } else { + m.Changes = m.Changes[:len(m.Changes)+1] + if m.Changes[len(m.Changes)-1] == nil { + m.Changes[len(m.Changes)-1] = &SignedBLSToExecutionChange{} + } + } + if err := m.Changes[len(m.Changes)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/libp2p/eth_vtproto.pb.go b/pkg/proto/libp2p/eth_vtproto.pb.go new file mode 100644 index 000000000..af684e07e --- /dev/null +++ b/pkg/proto/libp2p/eth_vtproto.pb.go @@ -0,0 +1,752 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/libp2p/eth.proto + +package libp2p + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *Status) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Status) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Status) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.EarliestAvailableSlot != nil { + size, err := (*wrapperspb.UInt64Value)(m.EarliestAvailableSlot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.HeadSlot != nil { + size, err := (*wrapperspb.UInt64Value)(m.HeadSlot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.HeadRoot != nil { + size, err := (*wrapperspb.StringValue)(m.HeadRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.FinalizedEpoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.FinalizedEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.FinalizedRoot != nil { + size, err := (*wrapperspb.StringValue)(m.FinalizedRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.ForkDigest != nil { + size, err := (*wrapperspb.StringValue)(m.ForkDigest).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Metadata) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Metadata) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Metadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.CustodyGroupCount != nil { + size, err := (*wrapperspb.UInt64Value)(m.CustodyGroupCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Syncnets != nil { + size, err := (*wrapperspb.StringValue)(m.Syncnets).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Attnets != nil { + size, err := (*wrapperspb.StringValue)(m.Attnets).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.SeqNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.SeqNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_Status = sync.Pool{ + New: func() interface{} { + return &Status{} + }, +} + +func (m *Status) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Status) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Status.Put(m) + } +} +func StatusFromVTPool() *Status { + return vtprotoPool_Status.Get().(*Status) +} + +var vtprotoPool_Metadata = sync.Pool{ + New: func() interface{} { + return &Metadata{} + }, +} + +func (m *Metadata) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Metadata) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Metadata.Put(m) + } +} +func MetadataFromVTPool() *Metadata { + return vtprotoPool_Metadata.Get().(*Metadata) +} +func (m *Status) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ForkDigest != nil { + l = (*wrapperspb.StringValue)(m.ForkDigest).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedRoot != nil { + l = (*wrapperspb.StringValue)(m.FinalizedRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedEpoch != nil { + l = (*wrapperspb.UInt64Value)(m.FinalizedEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HeadRoot != nil { + l = (*wrapperspb.StringValue)(m.HeadRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HeadSlot != nil { + l = (*wrapperspb.UInt64Value)(m.HeadSlot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.EarliestAvailableSlot != nil { + l = (*wrapperspb.UInt64Value)(m.EarliestAvailableSlot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Metadata) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SeqNumber != nil { + l = (*wrapperspb.UInt64Value)(m.SeqNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Attnets != nil { + l = (*wrapperspb.StringValue)(m.Attnets).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Syncnets != nil { + l = (*wrapperspb.StringValue)(m.Syncnets).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.CustodyGroupCount != nil { + l = (*wrapperspb.UInt64Value)(m.CustodyGroupCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Status) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Status: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkDigest", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ForkDigest == nil { + m.ForkDigest = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ForkDigest).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedRoot == nil { + m.FinalizedRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.FinalizedRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedEpoch == nil { + m.FinalizedEpoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.FinalizedEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeadRoot == nil { + m.HeadRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.HeadRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeadSlot == nil { + m.HeadSlot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.HeadSlot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EarliestAvailableSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EarliestAvailableSlot == nil { + m.EarliestAvailableSlot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.EarliestAvailableSlot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Metadata) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Metadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Metadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SeqNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SeqNumber == nil { + m.SeqNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SeqNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attnets", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Attnets == nil { + m.Attnets = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Attnets).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Syncnets", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Syncnets == nil { + m.Syncnets = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Syncnets).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustodyGroupCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CustodyGroupCount == nil { + m.CustodyGroupCount = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.CustodyGroupCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/libp2p/gossipsub/eth_vtproto.pb.go b/pkg/proto/libp2p/gossipsub/eth_vtproto.pb.go new file mode 100644 index 000000000..fbc385430 --- /dev/null +++ b/pkg/proto/libp2p/gossipsub/eth_vtproto.pb.go @@ -0,0 +1,1167 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/libp2p/gossipsub/eth.proto + +package gossipsub + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *BeaconBlock) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Block != nil { + size, err := (*wrapperspb.StringValue)(m.Block).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlobSidecar) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BlockRoot != nil { + size, err := (*wrapperspb.StringValue)(m.BlockRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.ParentRoot != nil { + size, err := (*wrapperspb.StringValue)(m.ParentRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.StateRoot != nil { + size, err := (*wrapperspb.StringValue)(m.StateRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DataColumnSidecar) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DataColumnSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DataColumnSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BlockRoot != nil { + size, err := (*wrapperspb.StringValue)(m.BlockRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.KzgCommitmentsCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.KzgCommitmentsCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.ParentRoot != nil { + size, err := (*wrapperspb.StringValue)(m.ParentRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.StateRoot != nil { + size, err := (*wrapperspb.StringValue)(m.StateRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_BeaconBlock = sync.Pool{ + New: func() interface{} { + return &BeaconBlock{} + }, +} + +func (m *BeaconBlock) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BeaconBlock) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BeaconBlock.Put(m) + } +} +func BeaconBlockFromVTPool() *BeaconBlock { + return vtprotoPool_BeaconBlock.Get().(*BeaconBlock) +} + +var vtprotoPool_BlobSidecar = sync.Pool{ + New: func() interface{} { + return &BlobSidecar{} + }, +} + +func (m *BlobSidecar) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BlobSidecar) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlobSidecar.Put(m) + } +} +func BlobSidecarFromVTPool() *BlobSidecar { + return vtprotoPool_BlobSidecar.Get().(*BlobSidecar) +} + +var vtprotoPool_DataColumnSidecar = sync.Pool{ + New: func() interface{} { + return &DataColumnSidecar{} + }, +} + +func (m *DataColumnSidecar) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *DataColumnSidecar) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DataColumnSidecar.Put(m) + } +} +func DataColumnSidecarFromVTPool() *DataColumnSidecar { + return vtprotoPool_DataColumnSidecar.Get().(*DataColumnSidecar) +} +func (m *BeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = (*wrapperspb.StringValue)(m.Block).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StateRoot != nil { + l = (*wrapperspb.StringValue)(m.StateRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ParentRoot != nil { + l = (*wrapperspb.StringValue)(m.ParentRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockRoot != nil { + l = (*wrapperspb.StringValue)(m.BlockRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DataColumnSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StateRoot != nil { + l = (*wrapperspb.StringValue)(m.StateRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ParentRoot != nil { + l = (*wrapperspb.StringValue)(m.ParentRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.KzgCommitmentsCount != nil { + l = (*wrapperspb.UInt32Value)(m.KzgCommitmentsCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockRoot != nil { + l = (*wrapperspb.StringValue)(m.BlockRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BeaconBlock) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BeaconBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BeaconBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Block).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlobSidecar) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlobSidecar: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlobSidecar: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateRoot == nil { + m.StateRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.StateRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ParentRoot == nil { + m.ParentRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ParentRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockRoot == nil { + m.BlockRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.BlockRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DataColumnSidecar) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DataColumnSidecar: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DataColumnSidecar: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateRoot == nil { + m.StateRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.StateRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ParentRoot == nil { + m.ParentRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ParentRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KzgCommitmentsCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.KzgCommitmentsCount == nil { + m.KzgCommitmentsCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.KzgCommitmentsCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockRoot == nil { + m.BlockRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.BlockRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/libp2p/peer_vtproto.pb.go b/pkg/proto/libp2p/peer_vtproto.pb.go new file mode 100644 index 000000000..d5fa35d30 --- /dev/null +++ b/pkg/proto/libp2p/peer_vtproto.pb.go @@ -0,0 +1,458 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/libp2p/peer.proto + +package libp2p + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *Peer) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Peer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Peer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Latency != nil { + size, err := (*wrapperspb.UInt64Value)(m.Latency).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.Protocols) > 0 { + for iNdEx := len(m.Protocols) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Protocols[iNdEx]) + copy(dAtA[i:], m.Protocols[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Protocols[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(m.ProtocolVersion) > 0 { + i -= len(m.ProtocolVersion) + copy(dAtA[i:], m.ProtocolVersion) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ProtocolVersion))) + i-- + dAtA[i] = 0x2a + } + if len(m.UserAgent) > 0 { + i -= len(m.UserAgent) + copy(dAtA[i:], m.UserAgent) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.UserAgent))) + i-- + dAtA[i] = 0x22 + } + if len(m.Ip) > 0 { + i -= len(m.Ip) + copy(dAtA[i:], m.Ip) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ip))) + i-- + dAtA[i] = 0x1a + } + if m.Port != nil { + size, err := (*wrapperspb.UInt32Value)(m.Port).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_Peer = sync.Pool{ + New: func() interface{} { + return &Peer{} + }, +} + +func (m *Peer) ResetVT() { + if m != nil { + f0 := m.Protocols[:0] + m.Reset() + m.Protocols = f0 + } +} +func (m *Peer) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Peer.Put(m) + } +} +func PeerFromVTPool() *Peer { + return vtprotoPool_Peer.Get().(*Peer) +} +func (m *Peer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Port != nil { + l = (*wrapperspb.UInt32Value)(m.Port).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Ip) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.UserAgent) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ProtocolVersion) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Protocols) > 0 { + for _, s := range m.Protocols { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Latency != nil { + l = (*wrapperspb.UInt64Value)(m.Latency).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Peer) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Peer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Peer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Port == nil { + m.Port = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Port).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ip = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UserAgent", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UserAgent = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProtocolVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProtocolVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Protocols", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Protocols = append(m.Protocols, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Latency", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Latency == nil { + m.Latency = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Latency).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/libp2p/trace_vtproto.pb.go b/pkg/proto/libp2p/trace_vtproto.pb.go new file mode 100644 index 000000000..7c4353743 --- /dev/null +++ b/pkg/proto/libp2p/trace_vtproto.pb.go @@ -0,0 +1,12289 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/libp2p/trace.proto + +package libp2p + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + timestamppb "github.com/planetscale/vtprotobuf/types/known/timestamppb" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb1 "google.golang.org/protobuf/types/known/timestamppb" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *AddPeer) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AddPeer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AddPeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Protocol != nil { + size, err := (*wrapperspb.StringValue)(m.Protocol).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RemovePeer) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RemovePeer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RemovePeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RecvRPC) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RecvRPC) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RecvRPC) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Meta != nil { + size, err := m.Meta.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SendRPC) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SendRPC) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SendRPC) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Meta != nil { + size, err := m.Meta.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DropRPC) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DropRPC) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DropRPC) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Meta != nil { + size, err := m.Meta.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Join) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Join) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Join) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Leave) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Leave) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Leave) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *Graft) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Graft) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Graft) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Prune) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Prune) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Prune) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PublishMessage) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PublishMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *PublishMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.MsgId != nil { + size, err := (*wrapperspb.StringValue)(m.MsgId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RejectMessage) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RejectMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RejectMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SeqNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.SeqNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.MsgSize != nil { + size, err := (*wrapperspb.UInt32Value)(m.MsgSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Local != nil { + size, err := (*wrapperspb.BoolValue)(m.Local).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Reason != nil { + size, err := (*wrapperspb.StringValue)(m.Reason).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.MsgId != nil { + size, err := (*wrapperspb.StringValue)(m.MsgId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DuplicateMessage) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DuplicateMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DuplicateMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SeqNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.SeqNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.MsgSize != nil { + size, err := (*wrapperspb.UInt32Value)(m.MsgSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Local != nil { + size, err := (*wrapperspb.BoolValue)(m.Local).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.MsgId != nil { + size, err := (*wrapperspb.StringValue)(m.MsgId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DeliverMessage) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeliverMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DeliverMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SeqNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.SeqNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.MsgSize != nil { + size, err := (*wrapperspb.UInt32Value)(m.MsgSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Local != nil { + size, err := (*wrapperspb.BoolValue)(m.Local).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.MsgId != nil { + size, err := (*wrapperspb.StringValue)(m.MsgId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TraceEventMetadata) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceEventMetadata) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *TraceEventMetadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Connected) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Connected) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Connected) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Limited != nil { + size, err := (*wrapperspb.BoolValue)(m.Limited).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.Transient != nil { + size, err := (*wrapperspb.BoolValue)(m.Transient).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Opened != nil { + size, err := (*timestamppb.Timestamp)(m.Opened).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Direction != nil { + size, err := (*wrapperspb.StringValue)(m.Direction).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.AgentVersion != nil { + size, err := (*wrapperspb.StringValue)(m.AgentVersion).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.RemoteMaddrs != nil { + size, err := (*wrapperspb.StringValue)(m.RemoteMaddrs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RemotePeer != nil { + size, err := (*wrapperspb.StringValue)(m.RemotePeer).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Disconnected) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Disconnected) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Disconnected) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Limited != nil { + size, err := (*wrapperspb.BoolValue)(m.Limited).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.Transient != nil { + size, err := (*wrapperspb.BoolValue)(m.Transient).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Opened != nil { + size, err := (*timestamppb.Timestamp)(m.Opened).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Direction != nil { + size, err := (*wrapperspb.StringValue)(m.Direction).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.AgentVersion != nil { + size, err := (*wrapperspb.StringValue)(m.AgentVersion).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.RemoteMaddrs != nil { + size, err := (*wrapperspb.StringValue)(m.RemoteMaddrs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RemotePeer != nil { + size, err := (*wrapperspb.StringValue)(m.RemotePeer).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *HandleStatus) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HandleStatus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *HandleStatus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Direction != nil { + size, err := (*wrapperspb.StringValue)(m.Direction).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.Response != nil { + size, err := m.Response.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Request != nil { + size, err := m.Request.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Latency != nil { + size, err := (*wrapperspb.FloatValue)(m.Latency).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Error != nil { + size, err := (*wrapperspb.StringValue)(m.Error).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.ProtocolId != nil { + size, err := (*wrapperspb.StringValue)(m.ProtocolId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *HandleMetadata) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HandleMetadata) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *HandleMetadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Direction != nil { + size, err := (*wrapperspb.StringValue)(m.Direction).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Latency != nil { + size, err := (*wrapperspb.FloatValue)(m.Latency).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Error != nil { + size, err := (*wrapperspb.StringValue)(m.Error).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.ProtocolId != nil { + size, err := (*wrapperspb.StringValue)(m.ProtocolId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SyntheticHeartbeat) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyntheticHeartbeat) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SyntheticHeartbeat) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ConnectionAgeNs != nil { + size, err := (*wrapperspb.Int64Value)(m.ConnectionAgeNs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if len(m.Protocols) > 0 { + for iNdEx := len(m.Protocols) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Protocols[iNdEx]) + copy(dAtA[i:], m.Protocols[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Protocols[iNdEx]))) + i-- + dAtA[i] = 0x3a + } + } + if m.Direction != nil { + size, err := (*wrapperspb.UInt32Value)(m.Direction).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.AgentVersion != nil { + size, err := (*wrapperspb.StringValue)(m.AgentVersion).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.LatencyMs != nil { + size, err := (*wrapperspb.Int64Value)(m.LatencyMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.RemoteMaddrs != nil { + size, err := (*wrapperspb.StringValue)(m.RemoteMaddrs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.RemotePeer != nil { + size, err := (*wrapperspb.StringValue)(m.RemotePeer).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Timestamp != nil { + size, err := (*timestamppb.Timestamp)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RPCMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RPCMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RPCMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Control != nil { + size, err := m.Control.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if len(m.Subscriptions) > 0 { + for iNdEx := len(m.Subscriptions) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Subscriptions[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Messages) > 0 { + for iNdEx := len(m.Messages) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Messages[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *MessageMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MessageMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *MessageMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.TopicId != nil { + size, err := (*wrapperspb.StringValue)(m.TopicId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MessageMetaItem) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MessageMetaItem) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *MessageMetaItem) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ControlIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.ControlIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.TopicId != nil { + size, err := (*wrapperspb.StringValue)(m.TopicId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RootEventId != nil { + size, err := (*wrapperspb.StringValue)(m.RootEventId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SubMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SubMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SubMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.TopicId != nil { + size, err := (*wrapperspb.StringValue)(m.TopicId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Subscribe != nil { + size, err := (*wrapperspb.BoolValue)(m.Subscribe).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SubMetaItem) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SubMetaItem) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SubMetaItem) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ControlIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.ControlIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Subscribe != nil { + size, err := (*wrapperspb.BoolValue)(m.Subscribe).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.TopicId != nil { + size, err := (*wrapperspb.StringValue)(m.TopicId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RootEventId != nil { + size, err := (*wrapperspb.StringValue)(m.RootEventId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControlMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Idontwant) > 0 { + for iNdEx := len(m.Idontwant) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Idontwant[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.Prune) > 0 { + for iNdEx := len(m.Prune) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Prune[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Graft) > 0 { + for iNdEx := len(m.Graft) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Graft[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Iwant) > 0 { + for iNdEx := len(m.Iwant) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Iwant[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Ihave) > 0 { + for iNdEx := len(m.Ihave) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Ihave[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ControlIHaveMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlIHaveMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlIHaveMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.MessageIds) > 0 { + for iNdEx := len(m.MessageIds) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.StringValue)(m.MessageIds[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if m.TopicId != nil { + size, err := (*wrapperspb.StringValue)(m.TopicId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControlIHaveMetaItem) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlIHaveMetaItem) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlIHaveMetaItem) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ControlIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.ControlIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.MessageIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.MessageIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RootEventId != nil { + size, err := (*wrapperspb.StringValue)(m.RootEventId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControlIWantMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlIWantMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlIWantMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.MessageIds) > 0 { + for iNdEx := len(m.MessageIds) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.StringValue)(m.MessageIds[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + return len(dAtA) - i, nil +} + +func (m *ControlIWantMetaItem) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlIWantMetaItem) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlIWantMetaItem) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ControlIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.ControlIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.MessageIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.MessageIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RootEventId != nil { + size, err := (*wrapperspb.StringValue)(m.RootEventId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControlGraftMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlGraftMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlGraftMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.TopicId != nil { + size, err := (*wrapperspb.StringValue)(m.TopicId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControlGraftMetaItem) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlGraftMetaItem) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlGraftMetaItem) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ControlIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.ControlIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RootEventId != nil { + size, err := (*wrapperspb.StringValue)(m.RootEventId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControlPruneMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlPruneMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlPruneMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.PeerIds) > 0 { + for iNdEx := len(m.PeerIds) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.StringValue)(m.PeerIds[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if m.TopicId != nil { + size, err := (*wrapperspb.StringValue)(m.TopicId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControlPruneMetaItem) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlPruneMetaItem) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlPruneMetaItem) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PeerIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.PeerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.ControlIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.ControlIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.GraftPeerId != nil { + size, err := (*wrapperspb.StringValue)(m.GraftPeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RootEventId != nil { + size, err := (*wrapperspb.StringValue)(m.RootEventId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ControlIDontWantMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlIDontWantMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlIDontWantMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.MessageIds) > 0 { + for iNdEx := len(m.MessageIds) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.StringValue)(m.MessageIds[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ControlIDontWantMetaItem) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ControlIDontWantMetaItem) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ControlIDontWantMetaItem) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ControlIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.ControlIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.MessageIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.MessageIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RootEventId != nil { + size, err := (*wrapperspb.StringValue)(m.RootEventId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DataColumnCustodyProbe) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DataColumnCustodyProbe) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DataColumnCustodyProbe) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Error != nil { + size, err := (*wrapperspb.StringValue)(m.Error).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if m.ResponseTimeMs != nil { + size, err := (*wrapperspb.Int64Value)(m.ResponseTimeMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + if m.Result != nil { + size, err := (*wrapperspb.StringValue)(m.Result).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + if m.BeaconBlockRoot != nil { + size, err := (*wrapperspb.StringValue)(m.BeaconBlockRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if m.ColumnRowsCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.ColumnRowsCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.ColumnIndex != nil { + size, err := (*wrapperspb.UInt32Value)(m.ColumnIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.WallclockRequestEpochStartDateTime != nil { + size, err := (*wrapperspb.UInt64Value)(m.WallclockRequestEpochStartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.WallclockRequestEpoch != nil { + size, err := (*wrapperspb.UInt32Value)(m.WallclockRequestEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.WallclockRequestSlotStartDateTime != nil { + size, err := (*wrapperspb.UInt64Value)(m.WallclockRequestSlotStartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.WallclockRequestSlot != nil { + size, err := (*wrapperspb.UInt32Value)(m.WallclockRequestSlot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.EpochStartDateTime != nil { + size, err := (*wrapperspb.UInt64Value)(m.EpochStartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Epoch != nil { + size, err := (*wrapperspb.UInt32Value)(m.Epoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.SlotStartDateTime != nil { + size, err := (*wrapperspb.UInt64Value)(m.SlotStartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt32Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.JobStartTimestamp != nil { + size, err := (*timestamppb.Timestamp)(m.JobStartTimestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Identify) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Identify) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Identify) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.RemoteMultiaddr != nil { + size, err := (*wrapperspb.StringValue)(m.RemoteMultiaddr).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if m.Direction != nil { + size, err := (*wrapperspb.StringValue)(m.Direction).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.Muxer != nil { + size, err := (*wrapperspb.StringValue)(m.Muxer).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.Security != nil { + size, err := (*wrapperspb.StringValue)(m.Security).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.Transport != nil { + size, err := (*wrapperspb.StringValue)(m.Transport).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.ObservedAddr != nil { + size, err := (*wrapperspb.StringValue)(m.ObservedAddr).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if len(m.ListenAddrs) > 0 { + for iNdEx := len(m.ListenAddrs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ListenAddrs[iNdEx]) + copy(dAtA[i:], m.ListenAddrs[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ListenAddrs[iNdEx]))) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Protocols) > 0 { + for iNdEx := len(m.Protocols) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Protocols[iNdEx]) + copy(dAtA[i:], m.Protocols[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Protocols[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if m.ProtocolVersion != nil { + size, err := (*wrapperspb.StringValue)(m.ProtocolVersion).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.AgentVersion != nil { + size, err := (*wrapperspb.StringValue)(m.AgentVersion).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Error != nil { + size, err := (*wrapperspb.StringValue)(m.Error).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Success != nil { + size, err := (*wrapperspb.BoolValue)(m.Success).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RemotePeer != nil { + size, err := (*wrapperspb.StringValue)(m.RemotePeer).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_AddPeer = sync.Pool{ + New: func() interface{} { + return &AddPeer{} + }, +} + +func (m *AddPeer) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *AddPeer) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AddPeer.Put(m) + } +} +func AddPeerFromVTPool() *AddPeer { + return vtprotoPool_AddPeer.Get().(*AddPeer) +} + +var vtprotoPool_RemovePeer = sync.Pool{ + New: func() interface{} { + return &RemovePeer{} + }, +} + +func (m *RemovePeer) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *RemovePeer) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_RemovePeer.Put(m) + } +} +func RemovePeerFromVTPool() *RemovePeer { + return vtprotoPool_RemovePeer.Get().(*RemovePeer) +} + +var vtprotoPool_RecvRPC = sync.Pool{ + New: func() interface{} { + return &RecvRPC{} + }, +} + +func (m *RecvRPC) ResetVT() { + if m != nil { + m.Meta.ReturnToVTPool() + m.Reset() + } +} +func (m *RecvRPC) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_RecvRPC.Put(m) + } +} +func RecvRPCFromVTPool() *RecvRPC { + return vtprotoPool_RecvRPC.Get().(*RecvRPC) +} + +var vtprotoPool_SendRPC = sync.Pool{ + New: func() interface{} { + return &SendRPC{} + }, +} + +func (m *SendRPC) ResetVT() { + if m != nil { + m.Meta.ReturnToVTPool() + m.Reset() + } +} +func (m *SendRPC) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SendRPC.Put(m) + } +} +func SendRPCFromVTPool() *SendRPC { + return vtprotoPool_SendRPC.Get().(*SendRPC) +} + +var vtprotoPool_DropRPC = sync.Pool{ + New: func() interface{} { + return &DropRPC{} + }, +} + +func (m *DropRPC) ResetVT() { + if m != nil { + m.Meta.ReturnToVTPool() + m.Reset() + } +} +func (m *DropRPC) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DropRPC.Put(m) + } +} +func DropRPCFromVTPool() *DropRPC { + return vtprotoPool_DropRPC.Get().(*DropRPC) +} + +var vtprotoPool_Join = sync.Pool{ + New: func() interface{} { + return &Join{} + }, +} + +func (m *Join) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Join) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Join.Put(m) + } +} +func JoinFromVTPool() *Join { + return vtprotoPool_Join.Get().(*Join) +} + +var vtprotoPool_Leave = sync.Pool{ + New: func() interface{} { + return &Leave{} + }, +} + +func (m *Leave) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Leave) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Leave.Put(m) + } +} +func LeaveFromVTPool() *Leave { + return vtprotoPool_Leave.Get().(*Leave) +} + +var vtprotoPool_Graft = sync.Pool{ + New: func() interface{} { + return &Graft{} + }, +} + +func (m *Graft) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Graft) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Graft.Put(m) + } +} +func GraftFromVTPool() *Graft { + return vtprotoPool_Graft.Get().(*Graft) +} + +var vtprotoPool_Prune = sync.Pool{ + New: func() interface{} { + return &Prune{} + }, +} + +func (m *Prune) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Prune) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Prune.Put(m) + } +} +func PruneFromVTPool() *Prune { + return vtprotoPool_Prune.Get().(*Prune) +} + +var vtprotoPool_PublishMessage = sync.Pool{ + New: func() interface{} { + return &PublishMessage{} + }, +} + +func (m *PublishMessage) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *PublishMessage) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_PublishMessage.Put(m) + } +} +func PublishMessageFromVTPool() *PublishMessage { + return vtprotoPool_PublishMessage.Get().(*PublishMessage) +} + +var vtprotoPool_RejectMessage = sync.Pool{ + New: func() interface{} { + return &RejectMessage{} + }, +} + +func (m *RejectMessage) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *RejectMessage) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_RejectMessage.Put(m) + } +} +func RejectMessageFromVTPool() *RejectMessage { + return vtprotoPool_RejectMessage.Get().(*RejectMessage) +} + +var vtprotoPool_DuplicateMessage = sync.Pool{ + New: func() interface{} { + return &DuplicateMessage{} + }, +} + +func (m *DuplicateMessage) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *DuplicateMessage) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DuplicateMessage.Put(m) + } +} +func DuplicateMessageFromVTPool() *DuplicateMessage { + return vtprotoPool_DuplicateMessage.Get().(*DuplicateMessage) +} + +var vtprotoPool_DeliverMessage = sync.Pool{ + New: func() interface{} { + return &DeliverMessage{} + }, +} + +func (m *DeliverMessage) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *DeliverMessage) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DeliverMessage.Put(m) + } +} +func DeliverMessageFromVTPool() *DeliverMessage { + return vtprotoPool_DeliverMessage.Get().(*DeliverMessage) +} + +var vtprotoPool_TraceEventMetadata = sync.Pool{ + New: func() interface{} { + return &TraceEventMetadata{} + }, +} + +func (m *TraceEventMetadata) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *TraceEventMetadata) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_TraceEventMetadata.Put(m) + } +} +func TraceEventMetadataFromVTPool() *TraceEventMetadata { + return vtprotoPool_TraceEventMetadata.Get().(*TraceEventMetadata) +} + +var vtprotoPool_Connected = sync.Pool{ + New: func() interface{} { + return &Connected{} + }, +} + +func (m *Connected) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Connected) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Connected.Put(m) + } +} +func ConnectedFromVTPool() *Connected { + return vtprotoPool_Connected.Get().(*Connected) +} + +var vtprotoPool_Disconnected = sync.Pool{ + New: func() interface{} { + return &Disconnected{} + }, +} + +func (m *Disconnected) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Disconnected) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Disconnected.Put(m) + } +} +func DisconnectedFromVTPool() *Disconnected { + return vtprotoPool_Disconnected.Get().(*Disconnected) +} + +var vtprotoPool_HandleStatus = sync.Pool{ + New: func() interface{} { + return &HandleStatus{} + }, +} + +func (m *HandleStatus) ResetVT() { + if m != nil { + m.Request.ReturnToVTPool() + m.Response.ReturnToVTPool() + m.Reset() + } +} +func (m *HandleStatus) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_HandleStatus.Put(m) + } +} +func HandleStatusFromVTPool() *HandleStatus { + return vtprotoPool_HandleStatus.Get().(*HandleStatus) +} + +var vtprotoPool_HandleMetadata = sync.Pool{ + New: func() interface{} { + return &HandleMetadata{} + }, +} + +func (m *HandleMetadata) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *HandleMetadata) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_HandleMetadata.Put(m) + } +} +func HandleMetadataFromVTPool() *HandleMetadata { + return vtprotoPool_HandleMetadata.Get().(*HandleMetadata) +} + +var vtprotoPool_SyntheticHeartbeat = sync.Pool{ + New: func() interface{} { + return &SyntheticHeartbeat{} + }, +} + +func (m *SyntheticHeartbeat) ResetVT() { + if m != nil { + f0 := m.Protocols[:0] + m.Reset() + m.Protocols = f0 + } +} +func (m *SyntheticHeartbeat) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SyntheticHeartbeat.Put(m) + } +} +func SyntheticHeartbeatFromVTPool() *SyntheticHeartbeat { + return vtprotoPool_SyntheticHeartbeat.Get().(*SyntheticHeartbeat) +} + +var vtprotoPool_RPCMeta = sync.Pool{ + New: func() interface{} { + return &RPCMeta{} + }, +} + +func (m *RPCMeta) ResetVT() { + if m != nil { + for _, mm := range m.Messages { + mm.ResetVT() + } + f0 := m.Messages[:0] + for _, mm := range m.Subscriptions { + mm.ResetVT() + } + f1 := m.Subscriptions[:0] + m.Control.ReturnToVTPool() + m.Reset() + m.Messages = f0 + m.Subscriptions = f1 + } +} +func (m *RPCMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_RPCMeta.Put(m) + } +} +func RPCMetaFromVTPool() *RPCMeta { + return vtprotoPool_RPCMeta.Get().(*RPCMeta) +} + +var vtprotoPool_MessageMeta = sync.Pool{ + New: func() interface{} { + return &MessageMeta{} + }, +} + +func (m *MessageMeta) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *MessageMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_MessageMeta.Put(m) + } +} +func MessageMetaFromVTPool() *MessageMeta { + return vtprotoPool_MessageMeta.Get().(*MessageMeta) +} + +var vtprotoPool_MessageMetaItem = sync.Pool{ + New: func() interface{} { + return &MessageMetaItem{} + }, +} + +func (m *MessageMetaItem) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *MessageMetaItem) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_MessageMetaItem.Put(m) + } +} +func MessageMetaItemFromVTPool() *MessageMetaItem { + return vtprotoPool_MessageMetaItem.Get().(*MessageMetaItem) +} + +var vtprotoPool_SubMeta = sync.Pool{ + New: func() interface{} { + return &SubMeta{} + }, +} + +func (m *SubMeta) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *SubMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SubMeta.Put(m) + } +} +func SubMetaFromVTPool() *SubMeta { + return vtprotoPool_SubMeta.Get().(*SubMeta) +} + +var vtprotoPool_SubMetaItem = sync.Pool{ + New: func() interface{} { + return &SubMetaItem{} + }, +} + +func (m *SubMetaItem) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *SubMetaItem) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SubMetaItem.Put(m) + } +} +func SubMetaItemFromVTPool() *SubMetaItem { + return vtprotoPool_SubMetaItem.Get().(*SubMetaItem) +} + +var vtprotoPool_ControlMeta = sync.Pool{ + New: func() interface{} { + return &ControlMeta{} + }, +} + +func (m *ControlMeta) ResetVT() { + if m != nil { + for _, mm := range m.Ihave { + mm.ResetVT() + } + f0 := m.Ihave[:0] + for _, mm := range m.Iwant { + mm.ResetVT() + } + f1 := m.Iwant[:0] + for _, mm := range m.Graft { + mm.ResetVT() + } + f2 := m.Graft[:0] + for _, mm := range m.Prune { + mm.ResetVT() + } + f3 := m.Prune[:0] + for _, mm := range m.Idontwant { + mm.ResetVT() + } + f4 := m.Idontwant[:0] + m.Reset() + m.Ihave = f0 + m.Iwant = f1 + m.Graft = f2 + m.Prune = f3 + m.Idontwant = f4 + } +} +func (m *ControlMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlMeta.Put(m) + } +} +func ControlMetaFromVTPool() *ControlMeta { + return vtprotoPool_ControlMeta.Get().(*ControlMeta) +} + +var vtprotoPool_ControlIHaveMeta = sync.Pool{ + New: func() interface{} { + return &ControlIHaveMeta{} + }, +} + +func (m *ControlIHaveMeta) ResetVT() { + if m != nil { + for _, mm := range m.MessageIds { + mm.Reset() + } + f0 := m.MessageIds[:0] + m.Reset() + m.MessageIds = f0 + } +} +func (m *ControlIHaveMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlIHaveMeta.Put(m) + } +} +func ControlIHaveMetaFromVTPool() *ControlIHaveMeta { + return vtprotoPool_ControlIHaveMeta.Get().(*ControlIHaveMeta) +} + +var vtprotoPool_ControlIHaveMetaItem = sync.Pool{ + New: func() interface{} { + return &ControlIHaveMetaItem{} + }, +} + +func (m *ControlIHaveMetaItem) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ControlIHaveMetaItem) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlIHaveMetaItem.Put(m) + } +} +func ControlIHaveMetaItemFromVTPool() *ControlIHaveMetaItem { + return vtprotoPool_ControlIHaveMetaItem.Get().(*ControlIHaveMetaItem) +} + +var vtprotoPool_ControlIWantMeta = sync.Pool{ + New: func() interface{} { + return &ControlIWantMeta{} + }, +} + +func (m *ControlIWantMeta) ResetVT() { + if m != nil { + for _, mm := range m.MessageIds { + mm.Reset() + } + f0 := m.MessageIds[:0] + m.Reset() + m.MessageIds = f0 + } +} +func (m *ControlIWantMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlIWantMeta.Put(m) + } +} +func ControlIWantMetaFromVTPool() *ControlIWantMeta { + return vtprotoPool_ControlIWantMeta.Get().(*ControlIWantMeta) +} + +var vtprotoPool_ControlIWantMetaItem = sync.Pool{ + New: func() interface{} { + return &ControlIWantMetaItem{} + }, +} + +func (m *ControlIWantMetaItem) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ControlIWantMetaItem) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlIWantMetaItem.Put(m) + } +} +func ControlIWantMetaItemFromVTPool() *ControlIWantMetaItem { + return vtprotoPool_ControlIWantMetaItem.Get().(*ControlIWantMetaItem) +} + +var vtprotoPool_ControlGraftMeta = sync.Pool{ + New: func() interface{} { + return &ControlGraftMeta{} + }, +} + +func (m *ControlGraftMeta) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ControlGraftMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlGraftMeta.Put(m) + } +} +func ControlGraftMetaFromVTPool() *ControlGraftMeta { + return vtprotoPool_ControlGraftMeta.Get().(*ControlGraftMeta) +} + +var vtprotoPool_ControlGraftMetaItem = sync.Pool{ + New: func() interface{} { + return &ControlGraftMetaItem{} + }, +} + +func (m *ControlGraftMetaItem) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ControlGraftMetaItem) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlGraftMetaItem.Put(m) + } +} +func ControlGraftMetaItemFromVTPool() *ControlGraftMetaItem { + return vtprotoPool_ControlGraftMetaItem.Get().(*ControlGraftMetaItem) +} + +var vtprotoPool_ControlPruneMeta = sync.Pool{ + New: func() interface{} { + return &ControlPruneMeta{} + }, +} + +func (m *ControlPruneMeta) ResetVT() { + if m != nil { + for _, mm := range m.PeerIds { + mm.Reset() + } + f0 := m.PeerIds[:0] + m.Reset() + m.PeerIds = f0 + } +} +func (m *ControlPruneMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlPruneMeta.Put(m) + } +} +func ControlPruneMetaFromVTPool() *ControlPruneMeta { + return vtprotoPool_ControlPruneMeta.Get().(*ControlPruneMeta) +} + +var vtprotoPool_ControlPruneMetaItem = sync.Pool{ + New: func() interface{} { + return &ControlPruneMetaItem{} + }, +} + +func (m *ControlPruneMetaItem) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ControlPruneMetaItem) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlPruneMetaItem.Put(m) + } +} +func ControlPruneMetaItemFromVTPool() *ControlPruneMetaItem { + return vtprotoPool_ControlPruneMetaItem.Get().(*ControlPruneMetaItem) +} + +var vtprotoPool_ControlIDontWantMeta = sync.Pool{ + New: func() interface{} { + return &ControlIDontWantMeta{} + }, +} + +func (m *ControlIDontWantMeta) ResetVT() { + if m != nil { + for _, mm := range m.MessageIds { + mm.Reset() + } + f0 := m.MessageIds[:0] + m.Reset() + m.MessageIds = f0 + } +} +func (m *ControlIDontWantMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlIDontWantMeta.Put(m) + } +} +func ControlIDontWantMetaFromVTPool() *ControlIDontWantMeta { + return vtprotoPool_ControlIDontWantMeta.Get().(*ControlIDontWantMeta) +} + +var vtprotoPool_ControlIDontWantMetaItem = sync.Pool{ + New: func() interface{} { + return &ControlIDontWantMetaItem{} + }, +} + +func (m *ControlIDontWantMetaItem) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ControlIDontWantMetaItem) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ControlIDontWantMetaItem.Put(m) + } +} +func ControlIDontWantMetaItemFromVTPool() *ControlIDontWantMetaItem { + return vtprotoPool_ControlIDontWantMetaItem.Get().(*ControlIDontWantMetaItem) +} + +var vtprotoPool_DataColumnCustodyProbe = sync.Pool{ + New: func() interface{} { + return &DataColumnCustodyProbe{} + }, +} + +func (m *DataColumnCustodyProbe) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *DataColumnCustodyProbe) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DataColumnCustodyProbe.Put(m) + } +} +func DataColumnCustodyProbeFromVTPool() *DataColumnCustodyProbe { + return vtprotoPool_DataColumnCustodyProbe.Get().(*DataColumnCustodyProbe) +} + +var vtprotoPool_Identify = sync.Pool{ + New: func() interface{} { + return &Identify{} + }, +} + +func (m *Identify) ResetVT() { + if m != nil { + f0 := m.Protocols[:0] + f1 := m.ListenAddrs[:0] + m.Reset() + m.Protocols = f0 + m.ListenAddrs = f1 + } +} +func (m *Identify) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Identify.Put(m) + } +} +func IdentifyFromVTPool() *Identify { + return vtprotoPool_Identify.Get().(*Identify) +} +func (m *AddPeer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Protocol != nil { + l = (*wrapperspb.StringValue)(m.Protocol).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *RemovePeer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *RecvRPC) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Meta != nil { + l = m.Meta.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SendRPC) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Meta != nil { + l = m.Meta.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DropRPC) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Meta != nil { + l = m.Meta.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Join) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Leave) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Graft) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Prune) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *PublishMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MsgId != nil { + l = (*wrapperspb.StringValue)(m.MsgId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *RejectMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MsgId != nil { + l = (*wrapperspb.StringValue)(m.MsgId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Reason != nil { + l = (*wrapperspb.StringValue)(m.Reason).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Local != nil { + l = (*wrapperspb.BoolValue)(m.Local).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MsgSize != nil { + l = (*wrapperspb.UInt32Value)(m.MsgSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SeqNumber != nil { + l = (*wrapperspb.UInt64Value)(m.SeqNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DuplicateMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MsgId != nil { + l = (*wrapperspb.StringValue)(m.MsgId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Local != nil { + l = (*wrapperspb.BoolValue)(m.Local).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MsgSize != nil { + l = (*wrapperspb.UInt32Value)(m.MsgSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SeqNumber != nil { + l = (*wrapperspb.UInt64Value)(m.SeqNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DeliverMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MsgId != nil { + l = (*wrapperspb.StringValue)(m.MsgId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Local != nil { + l = (*wrapperspb.BoolValue)(m.Local).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MsgSize != nil { + l = (*wrapperspb.UInt32Value)(m.MsgSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SeqNumber != nil { + l = (*wrapperspb.UInt64Value)(m.SeqNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *TraceEventMetadata) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Connected) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RemotePeer != nil { + l = (*wrapperspb.StringValue)(m.RemotePeer).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RemoteMaddrs != nil { + l = (*wrapperspb.StringValue)(m.RemoteMaddrs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AgentVersion != nil { + l = (*wrapperspb.StringValue)(m.AgentVersion).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Direction != nil { + l = (*wrapperspb.StringValue)(m.Direction).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Opened != nil { + l = (*timestamppb.Timestamp)(m.Opened).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Transient != nil { + l = (*wrapperspb.BoolValue)(m.Transient).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Limited != nil { + l = (*wrapperspb.BoolValue)(m.Limited).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Disconnected) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RemotePeer != nil { + l = (*wrapperspb.StringValue)(m.RemotePeer).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RemoteMaddrs != nil { + l = (*wrapperspb.StringValue)(m.RemoteMaddrs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AgentVersion != nil { + l = (*wrapperspb.StringValue)(m.AgentVersion).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Direction != nil { + l = (*wrapperspb.StringValue)(m.Direction).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Opened != nil { + l = (*timestamppb.Timestamp)(m.Opened).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Transient != nil { + l = (*wrapperspb.BoolValue)(m.Transient).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Limited != nil { + l = (*wrapperspb.BoolValue)(m.Limited).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *HandleStatus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProtocolId != nil { + l = (*wrapperspb.StringValue)(m.ProtocolId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Error != nil { + l = (*wrapperspb.StringValue)(m.Error).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Latency != nil { + l = (*wrapperspb.FloatValue)(m.Latency).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Request != nil { + l = m.Request.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Response != nil { + l = m.Response.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Direction != nil { + l = (*wrapperspb.StringValue)(m.Direction).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *HandleMetadata) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProtocolId != nil { + l = (*wrapperspb.StringValue)(m.ProtocolId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Error != nil { + l = (*wrapperspb.StringValue)(m.Error).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Latency != nil { + l = (*wrapperspb.FloatValue)(m.Latency).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Direction != nil { + l = (*wrapperspb.StringValue)(m.Direction).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SyntheticHeartbeat) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Timestamp != nil { + l = (*timestamppb.Timestamp)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RemotePeer != nil { + l = (*wrapperspb.StringValue)(m.RemotePeer).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RemoteMaddrs != nil { + l = (*wrapperspb.StringValue)(m.RemoteMaddrs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.LatencyMs != nil { + l = (*wrapperspb.Int64Value)(m.LatencyMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AgentVersion != nil { + l = (*wrapperspb.StringValue)(m.AgentVersion).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Direction != nil { + l = (*wrapperspb.UInt32Value)(m.Direction).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Protocols) > 0 { + for _, s := range m.Protocols { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ConnectionAgeNs != nil { + l = (*wrapperspb.Int64Value)(m.ConnectionAgeNs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *RPCMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Messages) > 0 { + for _, e := range m.Messages { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Subscriptions) > 0 { + for _, e := range m.Subscriptions { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Control != nil { + l = m.Control.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *MessageMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TopicId != nil { + l = (*wrapperspb.StringValue)(m.TopicId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *MessageMetaItem) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RootEventId != nil { + l = (*wrapperspb.StringValue)(m.RootEventId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TopicId != nil { + l = (*wrapperspb.StringValue)(m.TopicId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ControlIndex != nil { + l = (*wrapperspb.UInt32Value)(m.ControlIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SubMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Subscribe != nil { + l = (*wrapperspb.BoolValue)(m.Subscribe).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TopicId != nil { + l = (*wrapperspb.StringValue)(m.TopicId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SubMetaItem) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RootEventId != nil { + l = (*wrapperspb.StringValue)(m.RootEventId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TopicId != nil { + l = (*wrapperspb.StringValue)(m.TopicId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Subscribe != nil { + l = (*wrapperspb.BoolValue)(m.Subscribe).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ControlIndex != nil { + l = (*wrapperspb.UInt32Value)(m.ControlIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ControlMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Ihave) > 0 { + for _, e := range m.Ihave { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Iwant) > 0 { + for _, e := range m.Iwant { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Graft) > 0 { + for _, e := range m.Graft { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Prune) > 0 { + for _, e := range m.Prune { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Idontwant) > 0 { + for _, e := range m.Idontwant { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ControlIHaveMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TopicId != nil { + l = (*wrapperspb.StringValue)(m.TopicId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.MessageIds) > 0 { + for _, e := range m.MessageIds { + l = (*wrapperspb.StringValue)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ControlIHaveMetaItem) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RootEventId != nil { + l = (*wrapperspb.StringValue)(m.RootEventId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageIndex != nil { + l = (*wrapperspb.UInt32Value)(m.MessageIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ControlIndex != nil { + l = (*wrapperspb.UInt32Value)(m.ControlIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ControlIWantMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.MessageIds) > 0 { + for _, e := range m.MessageIds { + l = (*wrapperspb.StringValue)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ControlIWantMetaItem) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RootEventId != nil { + l = (*wrapperspb.StringValue)(m.RootEventId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageIndex != nil { + l = (*wrapperspb.UInt32Value)(m.MessageIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ControlIndex != nil { + l = (*wrapperspb.UInt32Value)(m.ControlIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ControlGraftMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TopicId != nil { + l = (*wrapperspb.StringValue)(m.TopicId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ControlGraftMetaItem) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RootEventId != nil { + l = (*wrapperspb.StringValue)(m.RootEventId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ControlIndex != nil { + l = (*wrapperspb.UInt32Value)(m.ControlIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ControlPruneMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TopicId != nil { + l = (*wrapperspb.StringValue)(m.TopicId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.PeerIds) > 0 { + for _, e := range m.PeerIds { + l = (*wrapperspb.StringValue)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ControlPruneMetaItem) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RootEventId != nil { + l = (*wrapperspb.StringValue)(m.RootEventId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GraftPeerId != nil { + l = (*wrapperspb.StringValue)(m.GraftPeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ControlIndex != nil { + l = (*wrapperspb.UInt32Value)(m.ControlIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerIndex != nil { + l = (*wrapperspb.UInt32Value)(m.PeerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ControlIDontWantMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.MessageIds) > 0 { + for _, e := range m.MessageIds { + l = (*wrapperspb.StringValue)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ControlIDontWantMetaItem) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RootEventId != nil { + l = (*wrapperspb.StringValue)(m.RootEventId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageIndex != nil { + l = (*wrapperspb.UInt32Value)(m.MessageIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ControlIndex != nil { + l = (*wrapperspb.UInt32Value)(m.ControlIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DataColumnCustodyProbe) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.JobStartTimestamp != nil { + l = (*timestamppb.Timestamp)(m.JobStartTimestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt32Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SlotStartDateTime != nil { + l = (*wrapperspb.UInt64Value)(m.SlotStartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = (*wrapperspb.UInt32Value)(m.Epoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.EpochStartDateTime != nil { + l = (*wrapperspb.UInt64Value)(m.EpochStartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockRequestSlot != nil { + l = (*wrapperspb.UInt32Value)(m.WallclockRequestSlot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockRequestSlotStartDateTime != nil { + l = (*wrapperspb.UInt64Value)(m.WallclockRequestSlotStartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockRequestEpoch != nil { + l = (*wrapperspb.UInt32Value)(m.WallclockRequestEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockRequestEpochStartDateTime != nil { + l = (*wrapperspb.UInt64Value)(m.WallclockRequestEpochStartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ColumnIndex != nil { + l = (*wrapperspb.UInt32Value)(m.ColumnIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ColumnRowsCount != nil { + l = (*wrapperspb.UInt32Value)(m.ColumnRowsCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BeaconBlockRoot != nil { + l = (*wrapperspb.StringValue)(m.BeaconBlockRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Result != nil { + l = (*wrapperspb.StringValue)(m.Result).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ResponseTimeMs != nil { + l = (*wrapperspb.Int64Value)(m.ResponseTimeMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Error != nil { + l = (*wrapperspb.StringValue)(m.Error).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Identify) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RemotePeer != nil { + l = (*wrapperspb.StringValue)(m.RemotePeer).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Success != nil { + l = (*wrapperspb.BoolValue)(m.Success).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Error != nil { + l = (*wrapperspb.StringValue)(m.Error).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AgentVersion != nil { + l = (*wrapperspb.StringValue)(m.AgentVersion).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProtocolVersion != nil { + l = (*wrapperspb.StringValue)(m.ProtocolVersion).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Protocols) > 0 { + for _, s := range m.Protocols { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.ListenAddrs) > 0 { + for _, s := range m.ListenAddrs { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ObservedAddr != nil { + l = (*wrapperspb.StringValue)(m.ObservedAddr).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Transport != nil { + l = (*wrapperspb.StringValue)(m.Transport).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Security != nil { + l = (*wrapperspb.StringValue)(m.Security).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Muxer != nil { + l = (*wrapperspb.StringValue)(m.Muxer).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Direction != nil { + l = (*wrapperspb.StringValue)(m.Direction).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RemoteMultiaddr != nil { + l = (*wrapperspb.StringValue)(m.RemoteMultiaddr).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AddPeer) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AddPeer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AddPeer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Protocol == nil { + m.Protocol = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Protocol).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RemovePeer) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RemovePeer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RemovePeer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RecvRPC) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RecvRPC: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RecvRPC: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Meta == nil { + m.Meta = RPCMetaFromVTPool() + } + if err := m.Meta.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SendRPC) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SendRPC: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SendRPC: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Meta == nil { + m.Meta = RPCMetaFromVTPool() + } + if err := m.Meta.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DropRPC) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DropRPC: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DropRPC: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Meta == nil { + m.Meta = RPCMetaFromVTPool() + } + if err := m.Meta.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Join) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Join: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Join: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Leave) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Leave: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Leave: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Graft) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Graft: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Graft: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Prune) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Prune: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Prune: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PublishMessage) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PublishMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PublishMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MsgId == nil { + m.MsgId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MsgId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RejectMessage) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RejectMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RejectMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MsgId == nil { + m.MsgId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MsgId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Reason == nil { + m.Reason = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Reason).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Local == nil { + m.Local = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Local).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MsgSize == nil { + m.MsgSize = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MsgSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SeqNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SeqNumber == nil { + m.SeqNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SeqNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DuplicateMessage) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DuplicateMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DuplicateMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MsgId == nil { + m.MsgId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MsgId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Local == nil { + m.Local = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Local).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MsgSize == nil { + m.MsgSize = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MsgSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SeqNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SeqNumber == nil { + m.SeqNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SeqNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeliverMessage) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeliverMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeliverMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MsgId == nil { + m.MsgId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MsgId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Local == nil { + m.Local = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Local).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MsgSize == nil { + m.MsgSize = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MsgSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SeqNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SeqNumber == nil { + m.SeqNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SeqNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceEventMetadata) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TraceEventMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TraceEventMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Connected) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Connected: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Connected: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemotePeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemotePeer == nil { + m.RemotePeer = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RemotePeer).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemoteMaddrs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemoteMaddrs == nil { + m.RemoteMaddrs = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RemoteMaddrs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AgentVersion", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AgentVersion == nil { + m.AgentVersion = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.AgentVersion).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Direction == nil { + m.Direction = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Direction).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Opened", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Opened == nil { + m.Opened = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.Opened).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transient", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Transient == nil { + m.Transient = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Transient).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Limited", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Limited == nil { + m.Limited = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Limited).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Disconnected) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Disconnected: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Disconnected: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemotePeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemotePeer == nil { + m.RemotePeer = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RemotePeer).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemoteMaddrs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemoteMaddrs == nil { + m.RemoteMaddrs = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RemoteMaddrs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AgentVersion", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AgentVersion == nil { + m.AgentVersion = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.AgentVersion).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Direction == nil { + m.Direction = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Direction).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Opened", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Opened == nil { + m.Opened = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.Opened).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transient", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Transient == nil { + m.Transient = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Transient).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Limited", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Limited == nil { + m.Limited = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Limited).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HandleStatus) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HandleStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HandleStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProtocolId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProtocolId == nil { + m.ProtocolId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ProtocolId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Error).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Latency", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Latency == nil { + m.Latency = &wrapperspb1.FloatValue{} + } + if err := (*wrapperspb.FloatValue)(m.Latency).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Request == nil { + m.Request = StatusFromVTPool() + } + if err := m.Request.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Response == nil { + m.Response = StatusFromVTPool() + } + if err := m.Response.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Direction == nil { + m.Direction = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Direction).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HandleMetadata) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HandleMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HandleMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProtocolId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProtocolId == nil { + m.ProtocolId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ProtocolId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Error).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Latency", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Latency == nil { + m.Latency = &wrapperspb1.FloatValue{} + } + if err := (*wrapperspb.FloatValue)(m.Latency).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = MetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Direction == nil { + m.Direction = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Direction).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyntheticHeartbeat) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyntheticHeartbeat: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyntheticHeartbeat: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemotePeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemotePeer == nil { + m.RemotePeer = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RemotePeer).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemoteMaddrs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemoteMaddrs == nil { + m.RemoteMaddrs = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RemoteMaddrs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatencyMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LatencyMs == nil { + m.LatencyMs = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.LatencyMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AgentVersion", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AgentVersion == nil { + m.AgentVersion = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.AgentVersion).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Direction == nil { + m.Direction = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Direction).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Protocols", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Protocols = append(m.Protocols, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionAgeNs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ConnectionAgeNs == nil { + m.ConnectionAgeNs = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.ConnectionAgeNs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RPCMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RPCMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RPCMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Messages) == cap(m.Messages) { + m.Messages = append(m.Messages, &MessageMeta{}) + } else { + m.Messages = m.Messages[:len(m.Messages)+1] + if m.Messages[len(m.Messages)-1] == nil { + m.Messages[len(m.Messages)-1] = &MessageMeta{} + } + } + if err := m.Messages[len(m.Messages)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Subscriptions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Subscriptions) == cap(m.Subscriptions) { + m.Subscriptions = append(m.Subscriptions, &SubMeta{}) + } else { + m.Subscriptions = m.Subscriptions[:len(m.Subscriptions)+1] + if m.Subscriptions[len(m.Subscriptions)-1] == nil { + m.Subscriptions[len(m.Subscriptions)-1] = &SubMeta{} + } + } + if err := m.Subscriptions[len(m.Subscriptions)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Control", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Control == nil { + m.Control = ControlMetaFromVTPool() + } + if err := m.Control.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MessageMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MessageMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MessageMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TopicId == nil { + m.TopicId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TopicId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MessageMetaItem) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MessageMetaItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MessageMetaItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootEventId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RootEventId == nil { + m.RootEventId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RootEventId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TopicId == nil { + m.TopicId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TopicId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ControlIndex == nil { + m.ControlIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ControlIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SubMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SubMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SubMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Subscribe", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Subscribe == nil { + m.Subscribe = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Subscribe).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TopicId == nil { + m.TopicId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TopicId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SubMetaItem) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SubMetaItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SubMetaItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootEventId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RootEventId == nil { + m.RootEventId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RootEventId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TopicId == nil { + m.TopicId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TopicId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Subscribe", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Subscribe == nil { + m.Subscribe = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Subscribe).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ControlIndex == nil { + m.ControlIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ControlIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ihave", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Ihave) == cap(m.Ihave) { + m.Ihave = append(m.Ihave, &ControlIHaveMeta{}) + } else { + m.Ihave = m.Ihave[:len(m.Ihave)+1] + if m.Ihave[len(m.Ihave)-1] == nil { + m.Ihave[len(m.Ihave)-1] = &ControlIHaveMeta{} + } + } + if err := m.Ihave[len(m.Ihave)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Iwant", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Iwant) == cap(m.Iwant) { + m.Iwant = append(m.Iwant, &ControlIWantMeta{}) + } else { + m.Iwant = m.Iwant[:len(m.Iwant)+1] + if m.Iwant[len(m.Iwant)-1] == nil { + m.Iwant[len(m.Iwant)-1] = &ControlIWantMeta{} + } + } + if err := m.Iwant[len(m.Iwant)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Graft", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Graft) == cap(m.Graft) { + m.Graft = append(m.Graft, &ControlGraftMeta{}) + } else { + m.Graft = m.Graft[:len(m.Graft)+1] + if m.Graft[len(m.Graft)-1] == nil { + m.Graft[len(m.Graft)-1] = &ControlGraftMeta{} + } + } + if err := m.Graft[len(m.Graft)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prune", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Prune) == cap(m.Prune) { + m.Prune = append(m.Prune, &ControlPruneMeta{}) + } else { + m.Prune = m.Prune[:len(m.Prune)+1] + if m.Prune[len(m.Prune)-1] == nil { + m.Prune[len(m.Prune)-1] = &ControlPruneMeta{} + } + } + if err := m.Prune[len(m.Prune)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Idontwant", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Idontwant) == cap(m.Idontwant) { + m.Idontwant = append(m.Idontwant, &ControlIDontWantMeta{}) + } else { + m.Idontwant = m.Idontwant[:len(m.Idontwant)+1] + if m.Idontwant[len(m.Idontwant)-1] == nil { + m.Idontwant[len(m.Idontwant)-1] = &ControlIDontWantMeta{} + } + } + if err := m.Idontwant[len(m.Idontwant)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlIHaveMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlIHaveMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlIHaveMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TopicId == nil { + m.TopicId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TopicId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIds", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.MessageIds) == cap(m.MessageIds) { + m.MessageIds = append(m.MessageIds, &wrapperspb1.StringValue{}) + } else { + m.MessageIds = m.MessageIds[:len(m.MessageIds)+1] + if m.MessageIds[len(m.MessageIds)-1] == nil { + m.MessageIds[len(m.MessageIds)-1] = &wrapperspb1.StringValue{} + } + } + if err := (*wrapperspb.StringValue)(m.MessageIds[len(m.MessageIds)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlIHaveMetaItem) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlIHaveMetaItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlIHaveMetaItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootEventId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RootEventId == nil { + m.RootEventId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RootEventId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageIndex == nil { + m.MessageIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MessageIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ControlIndex == nil { + m.ControlIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ControlIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlIWantMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlIWantMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlIWantMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIds", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.MessageIds) == cap(m.MessageIds) { + m.MessageIds = append(m.MessageIds, &wrapperspb1.StringValue{}) + } else { + m.MessageIds = m.MessageIds[:len(m.MessageIds)+1] + if m.MessageIds[len(m.MessageIds)-1] == nil { + m.MessageIds[len(m.MessageIds)-1] = &wrapperspb1.StringValue{} + } + } + if err := (*wrapperspb.StringValue)(m.MessageIds[len(m.MessageIds)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlIWantMetaItem) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlIWantMetaItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlIWantMetaItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootEventId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RootEventId == nil { + m.RootEventId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RootEventId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageIndex == nil { + m.MessageIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MessageIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ControlIndex == nil { + m.ControlIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ControlIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlGraftMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlGraftMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlGraftMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TopicId == nil { + m.TopicId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TopicId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlGraftMetaItem) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlGraftMetaItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlGraftMetaItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootEventId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RootEventId == nil { + m.RootEventId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RootEventId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ControlIndex == nil { + m.ControlIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ControlIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlPruneMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlPruneMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlPruneMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TopicId == nil { + m.TopicId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TopicId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerIds", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.PeerIds) == cap(m.PeerIds) { + m.PeerIds = append(m.PeerIds, &wrapperspb1.StringValue{}) + } else { + m.PeerIds = m.PeerIds[:len(m.PeerIds)+1] + if m.PeerIds[len(m.PeerIds)-1] == nil { + m.PeerIds[len(m.PeerIds)-1] = &wrapperspb1.StringValue{} + } + } + if err := (*wrapperspb.StringValue)(m.PeerIds[len(m.PeerIds)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlPruneMetaItem) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlPruneMetaItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlPruneMetaItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootEventId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RootEventId == nil { + m.RootEventId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RootEventId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GraftPeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GraftPeerId == nil { + m.GraftPeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.GraftPeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ControlIndex == nil { + m.ControlIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ControlIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerIndex == nil { + m.PeerIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.PeerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlIDontWantMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlIDontWantMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlIDontWantMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIds", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.MessageIds) == cap(m.MessageIds) { + m.MessageIds = append(m.MessageIds, &wrapperspb1.StringValue{}) + } else { + m.MessageIds = m.MessageIds[:len(m.MessageIds)+1] + if m.MessageIds[len(m.MessageIds)-1] == nil { + m.MessageIds[len(m.MessageIds)-1] = &wrapperspb1.StringValue{} + } + } + if err := (*wrapperspb.StringValue)(m.MessageIds[len(m.MessageIds)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ControlIDontWantMetaItem) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ControlIDontWantMetaItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ControlIDontWantMetaItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RootEventId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RootEventId == nil { + m.RootEventId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RootEventId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageIndex == nil { + m.MessageIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MessageIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ControlIndex == nil { + m.ControlIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ControlIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DataColumnCustodyProbe) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DataColumnCustodyProbe: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DataColumnCustodyProbe: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobStartTimestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JobStartTimestamp == nil { + m.JobStartTimestamp = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.JobStartTimestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SlotStartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SlotStartDateTime == nil { + m.SlotStartDateTime = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SlotStartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Epoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochStartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EpochStartDateTime == nil { + m.EpochStartDateTime = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.EpochStartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockRequestSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockRequestSlot == nil { + m.WallclockRequestSlot = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.WallclockRequestSlot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockRequestSlotStartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockRequestSlotStartDateTime == nil { + m.WallclockRequestSlotStartDateTime = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.WallclockRequestSlotStartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockRequestEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockRequestEpoch == nil { + m.WallclockRequestEpoch = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.WallclockRequestEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockRequestEpochStartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockRequestEpochStartDateTime == nil { + m.WallclockRequestEpochStartDateTime = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.WallclockRequestEpochStartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ColumnIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ColumnIndex == nil { + m.ColumnIndex = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ColumnIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ColumnRowsCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ColumnRowsCount == nil { + m.ColumnRowsCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ColumnRowsCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BeaconBlockRoot == nil { + m.BeaconBlockRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.BeaconBlockRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Result == nil { + m.Result = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Result).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseTimeMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ResponseTimeMs == nil { + m.ResponseTimeMs = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.ResponseTimeMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Error).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Identify) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Identify: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Identify: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemotePeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemotePeer == nil { + m.RemotePeer = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RemotePeer).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Success == nil { + m.Success = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Success).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Error).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AgentVersion", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AgentVersion == nil { + m.AgentVersion = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.AgentVersion).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProtocolVersion", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProtocolVersion == nil { + m.ProtocolVersion = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ProtocolVersion).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Protocols", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Protocols = append(m.Protocols, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListenAddrs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ListenAddrs = append(m.ListenAddrs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObservedAddr", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ObservedAddr == nil { + m.ObservedAddr = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ObservedAddr).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Transport", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Transport == nil { + m.Transport = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Transport).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Security", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Security == nil { + m.Security = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Security).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Muxer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Muxer == nil { + m.Muxer = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Muxer).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Direction == nil { + m.Direction = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Direction).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemoteMultiaddr", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RemoteMultiaddr == nil { + m.RemoteMultiaddr = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.RemoteMultiaddr).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/mevrelay/bids_vtproto.pb.go b/pkg/proto/mevrelay/bids_vtproto.pb.go new file mode 100644 index 000000000..df8869280 --- /dev/null +++ b/pkg/proto/mevrelay/bids_vtproto.pb.go @@ -0,0 +1,837 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/mevrelay/bids.proto + +package mevrelay + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *BidTrace) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BidTrace) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BidTrace) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.OptimisticSubmission != nil { + size, err := (*wrapperspb.BoolValue)(m.OptimisticSubmission).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + if m.TimestampMs != nil { + size, err := (*wrapperspb.Int64Value)(m.TimestampMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.Int64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.NumTx != nil { + size, err := (*wrapperspb.UInt64Value)(m.NumTx).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.Value != nil { + size, err := (*wrapperspb.StringValue)(m.Value).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.ProposerFeeRecipient != nil { + size, err := (*wrapperspb.StringValue)(m.ProposerFeeRecipient).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.ProposerPubkey != nil { + size, err := (*wrapperspb.StringValue)(m.ProposerPubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.BuilderPubkey != nil { + size, err := (*wrapperspb.StringValue)(m.BuilderPubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.BlockHash != nil { + size, err := (*wrapperspb.StringValue)(m.BlockHash).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.ParentHash != nil { + size, err := (*wrapperspb.StringValue)(m.ParentHash).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_BidTrace = sync.Pool{ + New: func() interface{} { + return &BidTrace{} + }, +} + +func (m *BidTrace) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BidTrace) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BidTrace.Put(m) + } +} +func BidTraceFromVTPool() *BidTrace { + return vtprotoPool_BidTrace.Get().(*BidTrace) +} +func (m *BidTrace) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ParentHash != nil { + l = (*wrapperspb.StringValue)(m.ParentHash).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockHash != nil { + l = (*wrapperspb.StringValue)(m.BlockHash).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BuilderPubkey != nil { + l = (*wrapperspb.StringValue)(m.BuilderPubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerPubkey != nil { + l = (*wrapperspb.StringValue)(m.ProposerPubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerFeeRecipient != nil { + l = (*wrapperspb.StringValue)(m.ProposerFeeRecipient).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Value != nil { + l = (*wrapperspb.StringValue)(m.Value).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.NumTx != nil { + l = (*wrapperspb.UInt64Value)(m.NumTx).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.Int64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TimestampMs != nil { + l = (*wrapperspb.Int64Value)(m.TimestampMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.OptimisticSubmission != nil { + l = (*wrapperspb.BoolValue)(m.OptimisticSubmission).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BidTrace) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BidTrace: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BidTrace: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ParentHash == nil { + m.ParentHash = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ParentHash).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockHash == nil { + m.BlockHash = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.BlockHash).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BuilderPubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BuilderPubkey == nil { + m.BuilderPubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.BuilderPubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerPubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerPubkey == nil { + m.ProposerPubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ProposerPubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerFeeRecipient", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerFeeRecipient == nil { + m.ProposerFeeRecipient = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ProposerFeeRecipient).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Value).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NumTx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NumTx == nil { + m.NumTx = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.NumTx).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TimestampMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TimestampMs == nil { + m.TimestampMs = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.TimestampMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OptimisticSubmission", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.OptimisticSubmission == nil { + m.OptimisticSubmission = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.OptimisticSubmission).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/mevrelay/payloads_vtproto.pb.go b/pkg/proto/mevrelay/payloads_vtproto.pb.go new file mode 100644 index 000000000..559dc94e1 --- /dev/null +++ b/pkg/proto/mevrelay/payloads_vtproto.pb.go @@ -0,0 +1,687 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/mevrelay/payloads.proto + +package mevrelay + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *ProposerPayloadDelivered) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProposerPayloadDelivered) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProposerPayloadDelivered) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.NumTx != nil { + size, err := (*wrapperspb.UInt64Value)(m.NumTx).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.Value != nil { + size, err := (*wrapperspb.StringValue)(m.Value).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.ProposerFeeRecipient != nil { + size, err := (*wrapperspb.StringValue)(m.ProposerFeeRecipient).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.ProposerPubkey != nil { + size, err := (*wrapperspb.StringValue)(m.ProposerPubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.BuilderPubkey != nil { + size, err := (*wrapperspb.StringValue)(m.BuilderPubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.BlockHash != nil { + size, err := (*wrapperspb.StringValue)(m.BlockHash).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.ParentHash != nil { + size, err := (*wrapperspb.StringValue)(m.ParentHash).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_ProposerPayloadDelivered = sync.Pool{ + New: func() interface{} { + return &ProposerPayloadDelivered{} + }, +} + +func (m *ProposerPayloadDelivered) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ProposerPayloadDelivered) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ProposerPayloadDelivered.Put(m) + } +} +func ProposerPayloadDeliveredFromVTPool() *ProposerPayloadDelivered { + return vtprotoPool_ProposerPayloadDelivered.Get().(*ProposerPayloadDelivered) +} +func (m *ProposerPayloadDelivered) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ParentHash != nil { + l = (*wrapperspb.StringValue)(m.ParentHash).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockHash != nil { + l = (*wrapperspb.StringValue)(m.BlockHash).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BuilderPubkey != nil { + l = (*wrapperspb.StringValue)(m.BuilderPubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerPubkey != nil { + l = (*wrapperspb.StringValue)(m.ProposerPubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerFeeRecipient != nil { + l = (*wrapperspb.StringValue)(m.ProposerFeeRecipient).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Value != nil { + l = (*wrapperspb.StringValue)(m.Value).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.NumTx != nil { + l = (*wrapperspb.UInt64Value)(m.NumTx).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ProposerPayloadDelivered) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ProposerPayloadDelivered: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposerPayloadDelivered: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ParentHash == nil { + m.ParentHash = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ParentHash).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockHash == nil { + m.BlockHash = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.BlockHash).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BuilderPubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BuilderPubkey == nil { + m.BuilderPubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.BuilderPubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerPubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerPubkey == nil { + m.ProposerPubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ProposerPubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerFeeRecipient", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerFeeRecipient == nil { + m.ProposerFeeRecipient = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ProposerFeeRecipient).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Value).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NumTx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NumTx == nil { + m.NumTx = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.NumTx).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/mevrelay/relay_vtproto.pb.go b/pkg/proto/mevrelay/relay_vtproto.pb.go new file mode 100644 index 000000000..715bd4363 --- /dev/null +++ b/pkg/proto/mevrelay/relay_vtproto.pb.go @@ -0,0 +1,768 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/mevrelay/relay.proto + +package mevrelay + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *Relay) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Relay) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Relay) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Url != nil { + size, err := (*wrapperspb.StringValue)(m.Url).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Name != nil { + size, err := (*wrapperspb.StringValue)(m.Name).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorRegistrationMessage) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValidatorRegistrationMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ValidatorRegistrationMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Pubkey != nil { + size, err := (*wrapperspb.StringValue)(m.Pubkey).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Timestamp != nil { + size, err := (*wrapperspb.UInt64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.FeeRecipient != nil { + size, err := (*wrapperspb.StringValue)(m.FeeRecipient).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorRegistration) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValidatorRegistration) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ValidatorRegistration) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Signature != nil { + size, err := (*wrapperspb.StringValue)(m.Signature).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_Relay = sync.Pool{ + New: func() interface{} { + return &Relay{} + }, +} + +func (m *Relay) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Relay) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Relay.Put(m) + } +} +func RelayFromVTPool() *Relay { + return vtprotoPool_Relay.Get().(*Relay) +} + +var vtprotoPool_ValidatorRegistrationMessage = sync.Pool{ + New: func() interface{} { + return &ValidatorRegistrationMessage{} + }, +} + +func (m *ValidatorRegistrationMessage) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ValidatorRegistrationMessage) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ValidatorRegistrationMessage.Put(m) + } +} +func ValidatorRegistrationMessageFromVTPool() *ValidatorRegistrationMessage { + return vtprotoPool_ValidatorRegistrationMessage.Get().(*ValidatorRegistrationMessage) +} + +var vtprotoPool_ValidatorRegistration = sync.Pool{ + New: func() interface{} { + return &ValidatorRegistration{} + }, +} + +func (m *ValidatorRegistration) ResetVT() { + if m != nil { + m.Message.ReturnToVTPool() + m.Reset() + } +} +func (m *ValidatorRegistration) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ValidatorRegistration.Put(m) + } +} +func ValidatorRegistrationFromVTPool() *ValidatorRegistration { + return vtprotoPool_ValidatorRegistration.Get().(*ValidatorRegistration) +} +func (m *Relay) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Name != nil { + l = (*wrapperspb.StringValue)(m.Name).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Url != nil { + l = (*wrapperspb.StringValue)(m.Url).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ValidatorRegistrationMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FeeRecipient != nil { + l = (*wrapperspb.StringValue)(m.FeeRecipient).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.UInt64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Pubkey != nil { + l = (*wrapperspb.StringValue)(m.Pubkey).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ValidatorRegistration) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Signature != nil { + l = (*wrapperspb.StringValue)(m.Signature).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Relay) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Relay: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Relay: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Name == nil { + m.Name = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Name).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Url == nil { + m.Url = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Url).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorRegistrationMessage) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ValidatorRegistrationMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorRegistrationMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FeeRecipient == nil { + m.FeeRecipient = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.FeeRecipient).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pubkey == nil { + m.Pubkey = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Pubkey).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidatorRegistration) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ValidatorRegistration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorRegistration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Message == nil { + m.Message = ValidatorRegistrationMessageFromVTPool() + } + if err := m.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Signature == nil { + m.Signature = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Signature).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/noderecord/consensus_vtproto.pb.go b/pkg/proto/noderecord/consensus_vtproto.pb.go new file mode 100644 index 000000000..b0d8374b2 --- /dev/null +++ b/pkg/proto/noderecord/consensus_vtproto.pb.go @@ -0,0 +1,1097 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/noderecord/consensus.proto + +package noderecord + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + timestamppb "github.com/planetscale/vtprotobuf/types/known/timestamppb" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb1 "google.golang.org/protobuf/types/known/timestamppb" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *Consensus) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Consensus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Consensus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.HasIpv6 != nil { + size, err := (*wrapperspb.BoolValue)(m.HasIpv6).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + } + if m.Quic != nil { + size, err := (*wrapperspb.UInt32Value)(m.Quic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + if m.Udp != nil { + size, err := (*wrapperspb.UInt32Value)(m.Udp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if m.Tcp != nil { + size, err := (*wrapperspb.UInt32Value)(m.Tcp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if m.Ip != nil { + size, err := (*wrapperspb.StringValue)(m.Ip).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + if m.Cgc != nil { + size, err := (*wrapperspb.StringValue)(m.Cgc).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + if m.HeadSlotStartDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.HeadSlotStartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if m.HeadSlot != nil { + size, err := (*wrapperspb.UInt64Value)(m.HeadSlot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.HeadRoot != nil { + size, err := (*wrapperspb.StringValue)(m.HeadRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.FinalizedEpochStartDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.FinalizedEpochStartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.FinalizedEpoch != nil { + size, err := (*wrapperspb.UInt64Value)(m.FinalizedEpoch).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.FinalizedRoot != nil { + size, err := (*wrapperspb.StringValue)(m.FinalizedRoot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.NextForkDigest != nil { + size, err := (*wrapperspb.StringValue)(m.NextForkDigest).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.ForkDigest != nil { + size, err := (*wrapperspb.StringValue)(m.ForkDigest).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Name != nil { + size, err := (*wrapperspb.StringValue)(m.Name).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Timestamp != nil { + size, err := (*wrapperspb.Int64Value)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.PeerId != nil { + size, err := (*wrapperspb.StringValue)(m.PeerId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.NodeId != nil { + size, err := (*wrapperspb.StringValue)(m.NodeId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Enr != nil { + size, err := (*wrapperspb.StringValue)(m.Enr).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_Consensus = sync.Pool{ + New: func() interface{} { + return &Consensus{} + }, +} + +func (m *Consensus) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Consensus) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Consensus.Put(m) + } +} +func ConsensusFromVTPool() *Consensus { + return vtprotoPool_Consensus.Get().(*Consensus) +} +func (m *Consensus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Enr != nil { + l = (*wrapperspb.StringValue)(m.Enr).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.NodeId != nil { + l = (*wrapperspb.StringValue)(m.NodeId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PeerId != nil { + l = (*wrapperspb.StringValue)(m.PeerId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*wrapperspb.Int64Value)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Name != nil { + l = (*wrapperspb.StringValue)(m.Name).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ForkDigest != nil { + l = (*wrapperspb.StringValue)(m.ForkDigest).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.NextForkDigest != nil { + l = (*wrapperspb.StringValue)(m.NextForkDigest).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedRoot != nil { + l = (*wrapperspb.StringValue)(m.FinalizedRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedEpoch != nil { + l = (*wrapperspb.UInt64Value)(m.FinalizedEpoch).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedEpochStartDateTime != nil { + l = (*timestamppb.Timestamp)(m.FinalizedEpochStartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HeadRoot != nil { + l = (*wrapperspb.StringValue)(m.HeadRoot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HeadSlot != nil { + l = (*wrapperspb.UInt64Value)(m.HeadSlot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HeadSlotStartDateTime != nil { + l = (*timestamppb.Timestamp)(m.HeadSlotStartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Cgc != nil { + l = (*wrapperspb.StringValue)(m.Cgc).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Ip != nil { + l = (*wrapperspb.StringValue)(m.Ip).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Tcp != nil { + l = (*wrapperspb.UInt32Value)(m.Tcp).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Udp != nil { + l = (*wrapperspb.UInt32Value)(m.Udp).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Quic != nil { + l = (*wrapperspb.UInt32Value)(m.Quic).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HasIpv6 != nil { + l = (*wrapperspb.BoolValue)(m.HasIpv6).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Consensus) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Consensus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Consensus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Enr", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Enr == nil { + m.Enr = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Enr).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NodeId == nil { + m.NodeId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.NodeId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PeerId == nil { + m.PeerId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.PeerId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Name == nil { + m.Name = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Name).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkDigest", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ForkDigest == nil { + m.ForkDigest = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ForkDigest).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NextForkDigest", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NextForkDigest == nil { + m.NextForkDigest = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.NextForkDigest).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedRoot == nil { + m.FinalizedRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.FinalizedRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedEpoch == nil { + m.FinalizedEpoch = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.FinalizedEpoch).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpochStartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedEpochStartDateTime == nil { + m.FinalizedEpochStartDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.FinalizedEpochStartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadRoot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeadRoot == nil { + m.HeadRoot = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.HeadRoot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeadSlot == nil { + m.HeadSlot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.HeadSlot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadSlotStartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeadSlotStartDateTime == nil { + m.HeadSlotStartDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.HeadSlotStartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cgc", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Cgc == nil { + m.Cgc = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Cgc).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Ip == nil { + m.Ip = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Ip).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tcp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Tcp == nil { + m.Tcp = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Tcp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Udp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Udp == nil { + m.Udp = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Udp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Quic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Quic == nil { + m.Quic = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Quic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HasIpv6", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HasIpv6 == nil { + m.HasIpv6 = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.HasIpv6).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/noderecord/execution_vtproto.pb.go b/pkg/proto/noderecord/execution_vtproto.pb.go new file mode 100644 index 000000000..cdb141431 --- /dev/null +++ b/pkg/proto/noderecord/execution_vtproto.pb.go @@ -0,0 +1,889 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/noderecord/execution.proto + +package noderecord + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + timestamppb "github.com/planetscale/vtprotobuf/types/known/timestamppb" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb1 "google.golang.org/protobuf/types/known/timestamppb" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *Execution) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Execution) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Execution) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.HasIpv6 != nil { + size, err := (*wrapperspb.BoolValue)(m.HasIpv6).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + if m.Udp != nil { + size, err := (*wrapperspb.UInt32Value)(m.Udp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + if m.Tcp != nil { + size, err := (*wrapperspb.UInt32Value)(m.Tcp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if m.Ip != nil { + size, err := (*wrapperspb.StringValue)(m.Ip).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.NodeId != nil { + size, err := (*wrapperspb.StringValue)(m.NodeId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.ForkIdNext != nil { + size, err := (*wrapperspb.StringValue)(m.ForkIdNext).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.ForkIdHash != nil { + size, err := (*wrapperspb.StringValue)(m.ForkIdHash).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.Genesis != nil { + size, err := (*wrapperspb.StringValue)(m.Genesis).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.Head != nil { + size, err := (*wrapperspb.StringValue)(m.Head).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.TotalDifficulty != nil { + size, err := (*wrapperspb.StringValue)(m.TotalDifficulty).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.ProtocolVersion != nil { + size, err := (*wrapperspb.StringValue)(m.ProtocolVersion).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Capabilities != nil { + size, err := (*wrapperspb.StringValue)(m.Capabilities).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Name != nil { + size, err := (*wrapperspb.StringValue)(m.Name).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Timestamp != nil { + size, err := (*timestamppb.Timestamp)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Enr != nil { + size, err := (*wrapperspb.StringValue)(m.Enr).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +var vtprotoPool_Execution = sync.Pool{ + New: func() interface{} { + return &Execution{} + }, +} + +func (m *Execution) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Execution) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Execution.Put(m) + } +} +func ExecutionFromVTPool() *Execution { + return vtprotoPool_Execution.Get().(*Execution) +} +func (m *Execution) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Enr != nil { + l = (*wrapperspb.StringValue)(m.Enr).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*timestamppb.Timestamp)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Name != nil { + l = (*wrapperspb.StringValue)(m.Name).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Capabilities != nil { + l = (*wrapperspb.StringValue)(m.Capabilities).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProtocolVersion != nil { + l = (*wrapperspb.StringValue)(m.ProtocolVersion).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TotalDifficulty != nil { + l = (*wrapperspb.StringValue)(m.TotalDifficulty).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Head != nil { + l = (*wrapperspb.StringValue)(m.Head).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Genesis != nil { + l = (*wrapperspb.StringValue)(m.Genesis).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ForkIdHash != nil { + l = (*wrapperspb.StringValue)(m.ForkIdHash).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ForkIdNext != nil { + l = (*wrapperspb.StringValue)(m.ForkIdNext).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.NodeId != nil { + l = (*wrapperspb.StringValue)(m.NodeId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Ip != nil { + l = (*wrapperspb.StringValue)(m.Ip).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Tcp != nil { + l = (*wrapperspb.UInt32Value)(m.Tcp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Udp != nil { + l = (*wrapperspb.UInt32Value)(m.Udp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HasIpv6 != nil { + l = (*wrapperspb.BoolValue)(m.HasIpv6).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Execution) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Execution: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Execution: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Enr", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Enr == nil { + m.Enr = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Enr).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Name == nil { + m.Name = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Name).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Capabilities", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Capabilities == nil { + m.Capabilities = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Capabilities).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProtocolVersion", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProtocolVersion == nil { + m.ProtocolVersion = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ProtocolVersion).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalDifficulty", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TotalDifficulty == nil { + m.TotalDifficulty = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.TotalDifficulty).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Head", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Head == nil { + m.Head = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Head).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Genesis", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Genesis == nil { + m.Genesis = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Genesis).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkIdHash", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ForkIdHash == nil { + m.ForkIdHash = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ForkIdHash).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkIdNext", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ForkIdNext == nil { + m.ForkIdNext = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.ForkIdNext).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NodeId == nil { + m.NodeId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.NodeId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Ip == nil { + m.Ip = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Ip).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tcp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Tcp == nil { + m.Tcp = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Tcp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Udp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Udp == nil { + m.Udp = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Udp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HasIpv6", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HasIpv6 == nil { + m.HasIpv6 = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.HasIpv6).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/xatu/coordinator_vtproto.pb.go b/pkg/proto/xatu/coordinator_vtproto.pb.go new file mode 100644 index 000000000..1a47521d0 --- /dev/null +++ b/pkg/proto/xatu/coordinator_vtproto.pb.go @@ -0,0 +1,12422 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/xatu/coordinator.proto + +package xatu + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + timestamppb "github.com/planetscale/vtprotobuf/types/known/timestamppb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb1 "google.golang.org/protobuf/types/known/timestamppb" + io "io" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *CreateNodeRecordsRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateNodeRecordsRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateNodeRecordsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.NodeRecords) > 0 { + for iNdEx := len(m.NodeRecords) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.NodeRecords[iNdEx]) + copy(dAtA[i:], m.NodeRecords[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecords[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CreateNodeRecordsResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateNodeRecordsResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateNodeRecordsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *ListStalledExecutionNodeRecordsRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ListStalledExecutionNodeRecordsRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ListStalledExecutionNodeRecordsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PageSize != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PageSize)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ListStalledExecutionNodeRecordsResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ListStalledExecutionNodeRecordsResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ListStalledExecutionNodeRecordsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.NodeRecords) > 0 { + for iNdEx := len(m.NodeRecords) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.NodeRecords[iNdEx]) + copy(dAtA[i:], m.NodeRecords[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecords[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ExecutionNodeStatus_Capability) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionNodeStatus_Capability) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionNodeStatus_Capability) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Version != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x10 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionNodeStatus_ForkID) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionNodeStatus_ForkID) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionNodeStatus_ForkID) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Next != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Next)) + i-- + dAtA[i] = 0x10 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionNodeStatus) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionNodeStatus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionNodeStatus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ForkId != nil { + size, err := m.ForkId.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if len(m.Genesis) > 0 { + i -= len(m.Genesis) + copy(dAtA[i:], m.Genesis) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Genesis))) + i-- + dAtA[i] = 0x42 + } + if len(m.Head) > 0 { + i -= len(m.Head) + copy(dAtA[i:], m.Head) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Head))) + i-- + dAtA[i] = 0x3a + } + if len(m.TotalDifficulty) > 0 { + i -= len(m.TotalDifficulty) + copy(dAtA[i:], m.TotalDifficulty) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TotalDifficulty))) + i-- + dAtA[i] = 0x32 + } + if m.NetworkId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NetworkId)) + i-- + dAtA[i] = 0x28 + } + if m.ProtocolVersion != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProtocolVersion)) + i-- + dAtA[i] = 0x20 + } + if len(m.Capabilities) > 0 { + for iNdEx := len(m.Capabilities) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Capabilities[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + } + if len(m.NodeRecord) > 0 { + i -= len(m.NodeRecord) + copy(dAtA[i:], m.NodeRecord) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecord))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CreateExecutionNodeRecordStatusRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateExecutionNodeRecordStatusRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateExecutionNodeRecordStatusRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Status != nil { + size, err := m.Status.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CreateExecutionNodeRecordStatusResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateExecutionNodeRecordStatusResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateExecutionNodeRecordStatusResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *CoordinatedNodeRecord) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CoordinatedNodeRecord) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CoordinatedNodeRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ConnectionAttempts != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ConnectionAttempts)) + i-- + dAtA[i] = 0x18 + } + if m.Connected { + i-- + if m.Connected { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(m.NodeRecord) > 0 { + i -= len(m.NodeRecord) + copy(dAtA[i:], m.NodeRecord) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecord))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CoordinateExecutionNodeRecordsRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CoordinateExecutionNodeRecordsRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CoordinateExecutionNodeRecordsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Capabilities) > 0 { + for iNdEx := len(m.Capabilities) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Capabilities[iNdEx]) + copy(dAtA[i:], m.Capabilities[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Capabilities[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientId))) + i-- + dAtA[i] = 0x2a + } + if len(m.ForkIdHashes) > 0 { + for iNdEx := len(m.ForkIdHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ForkIdHashes[iNdEx]) + copy(dAtA[i:], m.ForkIdHashes[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ForkIdHashes[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(m.NetworkIds) > 0 { + var pksize2 int + for _, num := range m.NetworkIds { + pksize2 += protohelpers.SizeOfVarint(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range m.NetworkIds { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0x1a + } + if m.Limit != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Limit)) + i-- + dAtA[i] = 0x10 + } + if len(m.NodeRecords) > 0 { + for iNdEx := len(m.NodeRecords) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.NodeRecords[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CoordinateExecutionNodeRecordsResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CoordinateExecutionNodeRecordsResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CoordinateExecutionNodeRecordsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.RetryDelay != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RetryDelay)) + i-- + dAtA[i] = 0x10 + } + if len(m.NodeRecords) > 0 { + for iNdEx := len(m.NodeRecords) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.NodeRecords[iNdEx]) + copy(dAtA[i:], m.NodeRecords[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecords[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ConsensusNodeStatus) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConsensusNodeStatus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ConsensusNodeStatus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.PeerId) > 0 { + i -= len(m.PeerId) + copy(dAtA[i:], m.PeerId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PeerId))) + i-- + dAtA[i] = 0x72 + } + if len(m.NodeId) > 0 { + i -= len(m.NodeId) + copy(dAtA[i:], m.NodeId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeId))) + i-- + dAtA[i] = 0x6a + } + if m.NetworkId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NetworkId)) + i-- + dAtA[i] = 0x60 + } + if len(m.Cgc) > 0 { + i -= len(m.Cgc) + copy(dAtA[i:], m.Cgc) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Cgc))) + i-- + dAtA[i] = 0x5a + } + if m.HeadSlotStartDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.HeadSlotStartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.HeadSlot) > 0 { + i -= len(m.HeadSlot) + copy(dAtA[i:], m.HeadSlot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HeadSlot))) + i-- + dAtA[i] = 0x4a + } + if len(m.HeadRoot) > 0 { + i -= len(m.HeadRoot) + copy(dAtA[i:], m.HeadRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HeadRoot))) + i-- + dAtA[i] = 0x42 + } + if m.FinalizedEpochStartDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.FinalizedEpochStartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.FinalizedEpoch) > 0 { + i -= len(m.FinalizedEpoch) + copy(dAtA[i:], m.FinalizedEpoch) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FinalizedEpoch))) + i-- + dAtA[i] = 0x32 + } + if len(m.FinalizedRoot) > 0 { + i -= len(m.FinalizedRoot) + copy(dAtA[i:], m.FinalizedRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FinalizedRoot))) + i-- + dAtA[i] = 0x2a + } + if len(m.NextForkDigest) > 0 { + i -= len(m.NextForkDigest) + copy(dAtA[i:], m.NextForkDigest) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NextForkDigest))) + i-- + dAtA[i] = 0x22 + } + if len(m.ForkDigest) > 0 { + i -= len(m.ForkDigest) + copy(dAtA[i:], m.ForkDigest) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ForkDigest))) + i-- + dAtA[i] = 0x1a + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + } + if len(m.NodeRecord) > 0 { + i -= len(m.NodeRecord) + copy(dAtA[i:], m.NodeRecord) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecord))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ListStalledConsensusNodeRecordsRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ListStalledConsensusNodeRecordsRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ListStalledConsensusNodeRecordsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PageSize != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PageSize)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ListStalledConsensusNodeRecordsResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ListStalledConsensusNodeRecordsResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ListStalledConsensusNodeRecordsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.NodeRecords) > 0 { + for iNdEx := len(m.NodeRecords) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.NodeRecords[iNdEx]) + copy(dAtA[i:], m.NodeRecords[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecords[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CreateConsensusNodeRecordStatusRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateConsensusNodeRecordStatusRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateConsensusNodeRecordStatusRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Status != nil { + size, err := m.Status.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CreateConsensusNodeRecordStatusResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateConsensusNodeRecordStatusResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateConsensusNodeRecordStatusResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *CreateConsensusNodeRecordStatusesRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateConsensusNodeRecordStatusesRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateConsensusNodeRecordStatusesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Statuses) > 0 { + for iNdEx := len(m.Statuses) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Statuses[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CreateConsensusNodeRecordStatusesResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateConsensusNodeRecordStatusesResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateConsensusNodeRecordStatusesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *CoordinateConsensusNodeRecordsRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CoordinateConsensusNodeRecordsRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CoordinateConsensusNodeRecordsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Capabilities) > 0 { + for iNdEx := len(m.Capabilities) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Capabilities[iNdEx]) + copy(dAtA[i:], m.Capabilities[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Capabilities[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientId))) + i-- + dAtA[i] = 0x2a + } + if len(m.ForkIdHashes) > 0 { + for iNdEx := len(m.ForkIdHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ForkIdHashes[iNdEx]) + copy(dAtA[i:], m.ForkIdHashes[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ForkIdHashes[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(m.NetworkIds) > 0 { + var pksize2 int + for _, num := range m.NetworkIds { + pksize2 += protohelpers.SizeOfVarint(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range m.NetworkIds { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0x1a + } + if m.Limit != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Limit)) + i-- + dAtA[i] = 0x10 + } + if len(m.NodeRecords) > 0 { + for iNdEx := len(m.NodeRecords) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.NodeRecords[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CoordinateConsensusNodeRecordsResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CoordinateConsensusNodeRecordsResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CoordinateConsensusNodeRecordsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.RetryDelay != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RetryDelay)) + i-- + dAtA[i] = 0x10 + } + if len(m.NodeRecords) > 0 { + for iNdEx := len(m.NodeRecords) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.NodeRecords[iNdEx]) + copy(dAtA[i:], m.NodeRecords[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecords[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *GetDiscoveryNodeRecordRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetDiscoveryNodeRecordRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetDiscoveryNodeRecordRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ForkIdHashes) > 0 { + for iNdEx := len(m.ForkIdHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ForkIdHashes[iNdEx]) + copy(dAtA[i:], m.ForkIdHashes[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ForkIdHashes[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.NetworkIds) > 0 { + var pksize2 int + for _, num := range m.NetworkIds { + pksize2 += protohelpers.SizeOfVarint(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range m.NetworkIds { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetDiscoveryNodeRecordResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetDiscoveryNodeRecordResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetDiscoveryNodeRecordResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.NodeRecord) > 0 { + i -= len(m.NodeRecord) + copy(dAtA[i:], m.NodeRecord) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecord))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetDiscoveryExecutionNodeRecordRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetDiscoveryExecutionNodeRecordRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetDiscoveryExecutionNodeRecordRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ForkIdHashes) > 0 { + for iNdEx := len(m.ForkIdHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ForkIdHashes[iNdEx]) + copy(dAtA[i:], m.ForkIdHashes[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ForkIdHashes[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.NetworkIds) > 0 { + var pksize2 int + for _, num := range m.NetworkIds { + pksize2 += protohelpers.SizeOfVarint(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range m.NetworkIds { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetDiscoveryExecutionNodeRecordResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetDiscoveryExecutionNodeRecordResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetDiscoveryExecutionNodeRecordResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.NodeRecord) > 0 { + i -= len(m.NodeRecord) + copy(dAtA[i:], m.NodeRecord) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecord))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetDiscoveryConsensusNodeRecordRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetDiscoveryConsensusNodeRecordRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetDiscoveryConsensusNodeRecordRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ForkDigests) > 0 { + for iNdEx := len(m.ForkDigests) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ForkDigests[iNdEx]) + copy(dAtA[i:], m.ForkDigests[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ForkDigests[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.NetworkIds) > 0 { + var pksize2 int + for _, num := range m.NetworkIds { + pksize2 += protohelpers.SizeOfVarint(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range m.NetworkIds { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetDiscoveryConsensusNodeRecordResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetDiscoveryConsensusNodeRecordResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetDiscoveryConsensusNodeRecordResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.NodeRecord) > 0 { + i -= len(m.NodeRecord) + copy(dAtA[i:], m.NodeRecord) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NodeRecord))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BackfillingCheckpointMarker) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BackfillingCheckpointMarker) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BackfillingCheckpointMarker) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillEpoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BackfillEpoch)) + i-- + dAtA[i] = 0x10 + } + if m.FinalizedEpoch != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FinalizedEpoch)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockVoluntaryExit) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockVoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockVoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockProposerSlashing) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockProposerSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockProposerSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockDeposit) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockDeposit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockDeposit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockAttesterSlashing) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockAttesterSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockAttesterSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockBlsToExecutionChange) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockBlsToExecutionChange) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockBlsToExecutionChange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockExecutionTransaction) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockExecutionTransaction) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockExecutionTransaction) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockWithdrawal) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockWithdrawal) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockWithdrawal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlock) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV1BeaconBlobSidecar) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV1BeaconBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV1BeaconBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV1BeaconProposerDuty) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV1BeaconProposerDuty) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV1BeaconProposerDuty) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockElaboratedAttestation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockElaboratedAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockElaboratedAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV1BeaconValidators) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV1BeaconValidators) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV1BeaconValidators) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV1BeaconCommittee) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV1BeaconCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV1BeaconCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV1BeaconSyncCommittee) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV1BeaconSyncCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV1BeaconSyncCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CannonLocationEthV2BeaconBlockSyncAggregate) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocationEthV2BeaconBlockSyncAggregate) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocationEthV2BeaconBlockSyncAggregate) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.BackfillingCheckpointMarker != nil { + size, err := m.BackfillingCheckpointMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CannonLocation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CannonLocation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Data.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if m.Type != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 + } + if len(m.NetworkId) > 0 { + i -= len(m.NetworkId) + copy(dAtA[i:], m.NetworkId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NetworkId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CannonLocation_EthV2BeaconBlockVoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockVoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockVoluntaryExit != nil { + size, err := m.EthV2BeaconBlockVoluntaryExit.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlockProposerSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockProposerSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockProposerSlashing != nil { + size, err := m.EthV2BeaconBlockProposerSlashing.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlockDeposit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockDeposit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockDeposit != nil { + size, err := m.EthV2BeaconBlockDeposit.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlockAttesterSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockAttesterSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockAttesterSlashing != nil { + size, err := m.EthV2BeaconBlockAttesterSlashing.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlockBlsToExecutionChange) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockBlsToExecutionChange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockBlsToExecutionChange != nil { + size, err := m.EthV2BeaconBlockBlsToExecutionChange.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlockExecutionTransaction) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockExecutionTransaction) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockExecutionTransaction != nil { + size, err := m.EthV2BeaconBlockExecutionTransaction.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlockWithdrawal) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockWithdrawal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockWithdrawal != nil { + size, err := m.EthV2BeaconBlockWithdrawal.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlock != nil { + size, err := m.EthV2BeaconBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV1BeaconBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV1BeaconBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconBlobSidecar != nil { + size, err := m.EthV1BeaconBlobSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV1BeaconProposerDuty) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV1BeaconProposerDuty) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconProposerDuty != nil { + size, err := m.EthV1BeaconProposerDuty.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlockElaboratedAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockElaboratedAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockElaboratedAttestation != nil { + size, err := m.EthV2BeaconBlockElaboratedAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV1BeaconValidators) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV1BeaconValidators) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconValidators != nil { + size, err := m.EthV1BeaconValidators.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV1BeaconCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV1BeaconCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconCommittee != nil { + size, err := m.EthV1BeaconCommittee.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV1BeaconSyncCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV1BeaconSyncCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconSyncCommittee != nil { + size, err := m.EthV1BeaconSyncCommittee.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *CannonLocation_EthV2BeaconBlockSyncAggregate) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CannonLocation_EthV2BeaconBlockSyncAggregate) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockSyncAggregate != nil { + size, err := m.EthV2BeaconBlockSyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *GetCannonLocationRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetCannonLocationRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetCannonLocationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Type != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 + } + if len(m.NetworkId) > 0 { + i -= len(m.NetworkId) + copy(dAtA[i:], m.NetworkId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NetworkId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetCannonLocationResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetCannonLocationResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetCannonLocationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Location != nil { + size, err := m.Location.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpsertCannonLocationRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpsertCannonLocationRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UpsertCannonLocationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Location != nil { + size, err := m.Location.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpsertCannonLocationResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpsertCannonLocationResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UpsertCannonLocationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *RelayMonitorSlotMarker) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RelayMonitorSlotMarker) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RelayMonitorSlotMarker) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.CurrentSlot != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.CurrentSlot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *RelayMonitorLocationBidTrace) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RelayMonitorLocationBidTrace) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RelayMonitorLocationBidTrace) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SlotMarker != nil { + size, err := m.SlotMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RelayMonitorLocationPayloadDelivered) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RelayMonitorLocationPayloadDelivered) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RelayMonitorLocationPayloadDelivered) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SlotMarker != nil { + size, err := m.SlotMarker.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RelayMonitorLocation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RelayMonitorLocation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RelayMonitorLocation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Data.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if m.Type != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x20 + } + if len(m.RelayName) > 0 { + i -= len(m.RelayName) + copy(dAtA[i:], m.RelayName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RelayName))) + i-- + dAtA[i] = 0x1a + } + if len(m.MetaClientName) > 0 { + i -= len(m.MetaClientName) + copy(dAtA[i:], m.MetaClientName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MetaClientName))) + i-- + dAtA[i] = 0x12 + } + if len(m.MetaNetworkName) > 0 { + i -= len(m.MetaNetworkName) + copy(dAtA[i:], m.MetaNetworkName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MetaNetworkName))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RelayMonitorLocation_BidTrace) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RelayMonitorLocation_BidTrace) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BidTrace != nil { + size, err := m.BidTrace.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *RelayMonitorLocation_PayloadDelivered) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RelayMonitorLocation_PayloadDelivered) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.PayloadDelivered != nil { + size, err := m.PayloadDelivered.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + return len(dAtA) - i, nil +} +func (m *GetRelayMonitorLocationRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetRelayMonitorLocationRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetRelayMonitorLocationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Type != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x20 + } + if len(m.RelayName) > 0 { + i -= len(m.RelayName) + copy(dAtA[i:], m.RelayName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RelayName))) + i-- + dAtA[i] = 0x1a + } + if len(m.MetaClientName) > 0 { + i -= len(m.MetaClientName) + copy(dAtA[i:], m.MetaClientName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MetaClientName))) + i-- + dAtA[i] = 0x12 + } + if len(m.MetaNetworkName) > 0 { + i -= len(m.MetaNetworkName) + copy(dAtA[i:], m.MetaNetworkName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MetaNetworkName))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetRelayMonitorLocationResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetRelayMonitorLocationResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetRelayMonitorLocationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Location != nil { + size, err := m.Location.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpsertRelayMonitorLocationRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpsertRelayMonitorLocationRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UpsertRelayMonitorLocationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Location != nil { + size, err := m.Location.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpsertRelayMonitorLocationResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpsertRelayMonitorLocationResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UpsertRelayMonitorLocationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +var vtprotoPool_CreateNodeRecordsRequest = sync.Pool{ + New: func() interface{} { + return &CreateNodeRecordsRequest{} + }, +} + +func (m *CreateNodeRecordsRequest) ResetVT() { + if m != nil { + f0 := m.NodeRecords[:0] + m.Reset() + m.NodeRecords = f0 + } +} +func (m *CreateNodeRecordsRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateNodeRecordsRequest.Put(m) + } +} +func CreateNodeRecordsRequestFromVTPool() *CreateNodeRecordsRequest { + return vtprotoPool_CreateNodeRecordsRequest.Get().(*CreateNodeRecordsRequest) +} + +var vtprotoPool_CreateNodeRecordsResponse = sync.Pool{ + New: func() interface{} { + return &CreateNodeRecordsResponse{} + }, +} + +func (m *CreateNodeRecordsResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *CreateNodeRecordsResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateNodeRecordsResponse.Put(m) + } +} +func CreateNodeRecordsResponseFromVTPool() *CreateNodeRecordsResponse { + return vtprotoPool_CreateNodeRecordsResponse.Get().(*CreateNodeRecordsResponse) +} + +var vtprotoPool_ListStalledExecutionNodeRecordsRequest = sync.Pool{ + New: func() interface{} { + return &ListStalledExecutionNodeRecordsRequest{} + }, +} + +func (m *ListStalledExecutionNodeRecordsRequest) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ListStalledExecutionNodeRecordsRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ListStalledExecutionNodeRecordsRequest.Put(m) + } +} +func ListStalledExecutionNodeRecordsRequestFromVTPool() *ListStalledExecutionNodeRecordsRequest { + return vtprotoPool_ListStalledExecutionNodeRecordsRequest.Get().(*ListStalledExecutionNodeRecordsRequest) +} + +var vtprotoPool_ListStalledExecutionNodeRecordsResponse = sync.Pool{ + New: func() interface{} { + return &ListStalledExecutionNodeRecordsResponse{} + }, +} + +func (m *ListStalledExecutionNodeRecordsResponse) ResetVT() { + if m != nil { + f0 := m.NodeRecords[:0] + m.Reset() + m.NodeRecords = f0 + } +} +func (m *ListStalledExecutionNodeRecordsResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ListStalledExecutionNodeRecordsResponse.Put(m) + } +} +func ListStalledExecutionNodeRecordsResponseFromVTPool() *ListStalledExecutionNodeRecordsResponse { + return vtprotoPool_ListStalledExecutionNodeRecordsResponse.Get().(*ListStalledExecutionNodeRecordsResponse) +} + +var vtprotoPool_ExecutionNodeStatus_Capability = sync.Pool{ + New: func() interface{} { + return &ExecutionNodeStatus_Capability{} + }, +} + +func (m *ExecutionNodeStatus_Capability) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionNodeStatus_Capability) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionNodeStatus_Capability.Put(m) + } +} +func ExecutionNodeStatus_CapabilityFromVTPool() *ExecutionNodeStatus_Capability { + return vtprotoPool_ExecutionNodeStatus_Capability.Get().(*ExecutionNodeStatus_Capability) +} + +var vtprotoPool_ExecutionNodeStatus_ForkID = sync.Pool{ + New: func() interface{} { + return &ExecutionNodeStatus_ForkID{} + }, +} + +func (m *ExecutionNodeStatus_ForkID) ResetVT() { + if m != nil { + f0 := m.Hash[:0] + m.Reset() + m.Hash = f0 + } +} +func (m *ExecutionNodeStatus_ForkID) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionNodeStatus_ForkID.Put(m) + } +} +func ExecutionNodeStatus_ForkIDFromVTPool() *ExecutionNodeStatus_ForkID { + return vtprotoPool_ExecutionNodeStatus_ForkID.Get().(*ExecutionNodeStatus_ForkID) +} + +var vtprotoPool_ExecutionNodeStatus = sync.Pool{ + New: func() interface{} { + return &ExecutionNodeStatus{} + }, +} + +func (m *ExecutionNodeStatus) ResetVT() { + if m != nil { + for _, mm := range m.Capabilities { + mm.ResetVT() + } + f0 := m.Capabilities[:0] + f1 := m.Head[:0] + f2 := m.Genesis[:0] + m.ForkId.ReturnToVTPool() + m.Reset() + m.Capabilities = f0 + m.Head = f1 + m.Genesis = f2 + } +} +func (m *ExecutionNodeStatus) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionNodeStatus.Put(m) + } +} +func ExecutionNodeStatusFromVTPool() *ExecutionNodeStatus { + return vtprotoPool_ExecutionNodeStatus.Get().(*ExecutionNodeStatus) +} + +var vtprotoPool_CreateExecutionNodeRecordStatusRequest = sync.Pool{ + New: func() interface{} { + return &CreateExecutionNodeRecordStatusRequest{} + }, +} + +func (m *CreateExecutionNodeRecordStatusRequest) ResetVT() { + if m != nil { + m.Status.ReturnToVTPool() + m.Reset() + } +} +func (m *CreateExecutionNodeRecordStatusRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateExecutionNodeRecordStatusRequest.Put(m) + } +} +func CreateExecutionNodeRecordStatusRequestFromVTPool() *CreateExecutionNodeRecordStatusRequest { + return vtprotoPool_CreateExecutionNodeRecordStatusRequest.Get().(*CreateExecutionNodeRecordStatusRequest) +} + +var vtprotoPool_CreateExecutionNodeRecordStatusResponse = sync.Pool{ + New: func() interface{} { + return &CreateExecutionNodeRecordStatusResponse{} + }, +} + +func (m *CreateExecutionNodeRecordStatusResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *CreateExecutionNodeRecordStatusResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateExecutionNodeRecordStatusResponse.Put(m) + } +} +func CreateExecutionNodeRecordStatusResponseFromVTPool() *CreateExecutionNodeRecordStatusResponse { + return vtprotoPool_CreateExecutionNodeRecordStatusResponse.Get().(*CreateExecutionNodeRecordStatusResponse) +} + +var vtprotoPool_CoordinatedNodeRecord = sync.Pool{ + New: func() interface{} { + return &CoordinatedNodeRecord{} + }, +} + +func (m *CoordinatedNodeRecord) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *CoordinatedNodeRecord) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CoordinatedNodeRecord.Put(m) + } +} +func CoordinatedNodeRecordFromVTPool() *CoordinatedNodeRecord { + return vtprotoPool_CoordinatedNodeRecord.Get().(*CoordinatedNodeRecord) +} + +var vtprotoPool_CoordinateExecutionNodeRecordsRequest = sync.Pool{ + New: func() interface{} { + return &CoordinateExecutionNodeRecordsRequest{} + }, +} + +func (m *CoordinateExecutionNodeRecordsRequest) ResetVT() { + if m != nil { + for _, mm := range m.NodeRecords { + mm.ResetVT() + } + f0 := m.NodeRecords[:0] + f1 := m.NetworkIds[:0] + f2 := m.ForkIdHashes[:0] + f3 := m.Capabilities[:0] + m.Reset() + m.NodeRecords = f0 + m.NetworkIds = f1 + m.ForkIdHashes = f2 + m.Capabilities = f3 + } +} +func (m *CoordinateExecutionNodeRecordsRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CoordinateExecutionNodeRecordsRequest.Put(m) + } +} +func CoordinateExecutionNodeRecordsRequestFromVTPool() *CoordinateExecutionNodeRecordsRequest { + return vtprotoPool_CoordinateExecutionNodeRecordsRequest.Get().(*CoordinateExecutionNodeRecordsRequest) +} + +var vtprotoPool_CoordinateExecutionNodeRecordsResponse = sync.Pool{ + New: func() interface{} { + return &CoordinateExecutionNodeRecordsResponse{} + }, +} + +func (m *CoordinateExecutionNodeRecordsResponse) ResetVT() { + if m != nil { + f0 := m.NodeRecords[:0] + m.Reset() + m.NodeRecords = f0 + } +} +func (m *CoordinateExecutionNodeRecordsResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CoordinateExecutionNodeRecordsResponse.Put(m) + } +} +func CoordinateExecutionNodeRecordsResponseFromVTPool() *CoordinateExecutionNodeRecordsResponse { + return vtprotoPool_CoordinateExecutionNodeRecordsResponse.Get().(*CoordinateExecutionNodeRecordsResponse) +} + +var vtprotoPool_ConsensusNodeStatus = sync.Pool{ + New: func() interface{} { + return &ConsensusNodeStatus{} + }, +} + +func (m *ConsensusNodeStatus) ResetVT() { + if m != nil { + f0 := m.ForkDigest[:0] + f1 := m.NextForkDigest[:0] + f2 := m.FinalizedRoot[:0] + f3 := m.FinalizedEpoch[:0] + f4 := m.HeadRoot[:0] + f5 := m.HeadSlot[:0] + f6 := m.Cgc[:0] + m.Reset() + m.ForkDigest = f0 + m.NextForkDigest = f1 + m.FinalizedRoot = f2 + m.FinalizedEpoch = f3 + m.HeadRoot = f4 + m.HeadSlot = f5 + m.Cgc = f6 + } +} +func (m *ConsensusNodeStatus) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ConsensusNodeStatus.Put(m) + } +} +func ConsensusNodeStatusFromVTPool() *ConsensusNodeStatus { + return vtprotoPool_ConsensusNodeStatus.Get().(*ConsensusNodeStatus) +} + +var vtprotoPool_ListStalledConsensusNodeRecordsRequest = sync.Pool{ + New: func() interface{} { + return &ListStalledConsensusNodeRecordsRequest{} + }, +} + +func (m *ListStalledConsensusNodeRecordsRequest) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ListStalledConsensusNodeRecordsRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ListStalledConsensusNodeRecordsRequest.Put(m) + } +} +func ListStalledConsensusNodeRecordsRequestFromVTPool() *ListStalledConsensusNodeRecordsRequest { + return vtprotoPool_ListStalledConsensusNodeRecordsRequest.Get().(*ListStalledConsensusNodeRecordsRequest) +} + +var vtprotoPool_ListStalledConsensusNodeRecordsResponse = sync.Pool{ + New: func() interface{} { + return &ListStalledConsensusNodeRecordsResponse{} + }, +} + +func (m *ListStalledConsensusNodeRecordsResponse) ResetVT() { + if m != nil { + f0 := m.NodeRecords[:0] + m.Reset() + m.NodeRecords = f0 + } +} +func (m *ListStalledConsensusNodeRecordsResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ListStalledConsensusNodeRecordsResponse.Put(m) + } +} +func ListStalledConsensusNodeRecordsResponseFromVTPool() *ListStalledConsensusNodeRecordsResponse { + return vtprotoPool_ListStalledConsensusNodeRecordsResponse.Get().(*ListStalledConsensusNodeRecordsResponse) +} + +var vtprotoPool_CreateConsensusNodeRecordStatusRequest = sync.Pool{ + New: func() interface{} { + return &CreateConsensusNodeRecordStatusRequest{} + }, +} + +func (m *CreateConsensusNodeRecordStatusRequest) ResetVT() { + if m != nil { + m.Status.ReturnToVTPool() + m.Reset() + } +} +func (m *CreateConsensusNodeRecordStatusRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateConsensusNodeRecordStatusRequest.Put(m) + } +} +func CreateConsensusNodeRecordStatusRequestFromVTPool() *CreateConsensusNodeRecordStatusRequest { + return vtprotoPool_CreateConsensusNodeRecordStatusRequest.Get().(*CreateConsensusNodeRecordStatusRequest) +} + +var vtprotoPool_CreateConsensusNodeRecordStatusResponse = sync.Pool{ + New: func() interface{} { + return &CreateConsensusNodeRecordStatusResponse{} + }, +} + +func (m *CreateConsensusNodeRecordStatusResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *CreateConsensusNodeRecordStatusResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateConsensusNodeRecordStatusResponse.Put(m) + } +} +func CreateConsensusNodeRecordStatusResponseFromVTPool() *CreateConsensusNodeRecordStatusResponse { + return vtprotoPool_CreateConsensusNodeRecordStatusResponse.Get().(*CreateConsensusNodeRecordStatusResponse) +} + +var vtprotoPool_CreateConsensusNodeRecordStatusesRequest = sync.Pool{ + New: func() interface{} { + return &CreateConsensusNodeRecordStatusesRequest{} + }, +} + +func (m *CreateConsensusNodeRecordStatusesRequest) ResetVT() { + if m != nil { + for _, mm := range m.Statuses { + mm.ResetVT() + } + f0 := m.Statuses[:0] + m.Reset() + m.Statuses = f0 + } +} +func (m *CreateConsensusNodeRecordStatusesRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateConsensusNodeRecordStatusesRequest.Put(m) + } +} +func CreateConsensusNodeRecordStatusesRequestFromVTPool() *CreateConsensusNodeRecordStatusesRequest { + return vtprotoPool_CreateConsensusNodeRecordStatusesRequest.Get().(*CreateConsensusNodeRecordStatusesRequest) +} + +var vtprotoPool_CreateConsensusNodeRecordStatusesResponse = sync.Pool{ + New: func() interface{} { + return &CreateConsensusNodeRecordStatusesResponse{} + }, +} + +func (m *CreateConsensusNodeRecordStatusesResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *CreateConsensusNodeRecordStatusesResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateConsensusNodeRecordStatusesResponse.Put(m) + } +} +func CreateConsensusNodeRecordStatusesResponseFromVTPool() *CreateConsensusNodeRecordStatusesResponse { + return vtprotoPool_CreateConsensusNodeRecordStatusesResponse.Get().(*CreateConsensusNodeRecordStatusesResponse) +} + +var vtprotoPool_CoordinateConsensusNodeRecordsRequest = sync.Pool{ + New: func() interface{} { + return &CoordinateConsensusNodeRecordsRequest{} + }, +} + +func (m *CoordinateConsensusNodeRecordsRequest) ResetVT() { + if m != nil { + for _, mm := range m.NodeRecords { + mm.ResetVT() + } + f0 := m.NodeRecords[:0] + f1 := m.NetworkIds[:0] + f2 := m.ForkIdHashes[:0] + f3 := m.Capabilities[:0] + m.Reset() + m.NodeRecords = f0 + m.NetworkIds = f1 + m.ForkIdHashes = f2 + m.Capabilities = f3 + } +} +func (m *CoordinateConsensusNodeRecordsRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CoordinateConsensusNodeRecordsRequest.Put(m) + } +} +func CoordinateConsensusNodeRecordsRequestFromVTPool() *CoordinateConsensusNodeRecordsRequest { + return vtprotoPool_CoordinateConsensusNodeRecordsRequest.Get().(*CoordinateConsensusNodeRecordsRequest) +} + +var vtprotoPool_CoordinateConsensusNodeRecordsResponse = sync.Pool{ + New: func() interface{} { + return &CoordinateConsensusNodeRecordsResponse{} + }, +} + +func (m *CoordinateConsensusNodeRecordsResponse) ResetVT() { + if m != nil { + f0 := m.NodeRecords[:0] + m.Reset() + m.NodeRecords = f0 + } +} +func (m *CoordinateConsensusNodeRecordsResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CoordinateConsensusNodeRecordsResponse.Put(m) + } +} +func CoordinateConsensusNodeRecordsResponseFromVTPool() *CoordinateConsensusNodeRecordsResponse { + return vtprotoPool_CoordinateConsensusNodeRecordsResponse.Get().(*CoordinateConsensusNodeRecordsResponse) +} + +var vtprotoPool_GetDiscoveryNodeRecordRequest = sync.Pool{ + New: func() interface{} { + return &GetDiscoveryNodeRecordRequest{} + }, +} + +func (m *GetDiscoveryNodeRecordRequest) ResetVT() { + if m != nil { + f0 := m.NetworkIds[:0] + f1 := m.ForkIdHashes[:0] + m.Reset() + m.NetworkIds = f0 + m.ForkIdHashes = f1 + } +} +func (m *GetDiscoveryNodeRecordRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetDiscoveryNodeRecordRequest.Put(m) + } +} +func GetDiscoveryNodeRecordRequestFromVTPool() *GetDiscoveryNodeRecordRequest { + return vtprotoPool_GetDiscoveryNodeRecordRequest.Get().(*GetDiscoveryNodeRecordRequest) +} + +var vtprotoPool_GetDiscoveryNodeRecordResponse = sync.Pool{ + New: func() interface{} { + return &GetDiscoveryNodeRecordResponse{} + }, +} + +func (m *GetDiscoveryNodeRecordResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *GetDiscoveryNodeRecordResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetDiscoveryNodeRecordResponse.Put(m) + } +} +func GetDiscoveryNodeRecordResponseFromVTPool() *GetDiscoveryNodeRecordResponse { + return vtprotoPool_GetDiscoveryNodeRecordResponse.Get().(*GetDiscoveryNodeRecordResponse) +} + +var vtprotoPool_GetDiscoveryExecutionNodeRecordRequest = sync.Pool{ + New: func() interface{} { + return &GetDiscoveryExecutionNodeRecordRequest{} + }, +} + +func (m *GetDiscoveryExecutionNodeRecordRequest) ResetVT() { + if m != nil { + f0 := m.NetworkIds[:0] + f1 := m.ForkIdHashes[:0] + m.Reset() + m.NetworkIds = f0 + m.ForkIdHashes = f1 + } +} +func (m *GetDiscoveryExecutionNodeRecordRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetDiscoveryExecutionNodeRecordRequest.Put(m) + } +} +func GetDiscoveryExecutionNodeRecordRequestFromVTPool() *GetDiscoveryExecutionNodeRecordRequest { + return vtprotoPool_GetDiscoveryExecutionNodeRecordRequest.Get().(*GetDiscoveryExecutionNodeRecordRequest) +} + +var vtprotoPool_GetDiscoveryExecutionNodeRecordResponse = sync.Pool{ + New: func() interface{} { + return &GetDiscoveryExecutionNodeRecordResponse{} + }, +} + +func (m *GetDiscoveryExecutionNodeRecordResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *GetDiscoveryExecutionNodeRecordResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetDiscoveryExecutionNodeRecordResponse.Put(m) + } +} +func GetDiscoveryExecutionNodeRecordResponseFromVTPool() *GetDiscoveryExecutionNodeRecordResponse { + return vtprotoPool_GetDiscoveryExecutionNodeRecordResponse.Get().(*GetDiscoveryExecutionNodeRecordResponse) +} + +var vtprotoPool_GetDiscoveryConsensusNodeRecordRequest = sync.Pool{ + New: func() interface{} { + return &GetDiscoveryConsensusNodeRecordRequest{} + }, +} + +func (m *GetDiscoveryConsensusNodeRecordRequest) ResetVT() { + if m != nil { + f0 := m.NetworkIds[:0] + f1 := m.ForkDigests[:0] + m.Reset() + m.NetworkIds = f0 + m.ForkDigests = f1 + } +} +func (m *GetDiscoveryConsensusNodeRecordRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetDiscoveryConsensusNodeRecordRequest.Put(m) + } +} +func GetDiscoveryConsensusNodeRecordRequestFromVTPool() *GetDiscoveryConsensusNodeRecordRequest { + return vtprotoPool_GetDiscoveryConsensusNodeRecordRequest.Get().(*GetDiscoveryConsensusNodeRecordRequest) +} + +var vtprotoPool_GetDiscoveryConsensusNodeRecordResponse = sync.Pool{ + New: func() interface{} { + return &GetDiscoveryConsensusNodeRecordResponse{} + }, +} + +func (m *GetDiscoveryConsensusNodeRecordResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *GetDiscoveryConsensusNodeRecordResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetDiscoveryConsensusNodeRecordResponse.Put(m) + } +} +func GetDiscoveryConsensusNodeRecordResponseFromVTPool() *GetDiscoveryConsensusNodeRecordResponse { + return vtprotoPool_GetDiscoveryConsensusNodeRecordResponse.Get().(*GetDiscoveryConsensusNodeRecordResponse) +} + +var vtprotoPool_BackfillingCheckpointMarker = sync.Pool{ + New: func() interface{} { + return &BackfillingCheckpointMarker{} + }, +} + +func (m *BackfillingCheckpointMarker) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *BackfillingCheckpointMarker) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BackfillingCheckpointMarker.Put(m) + } +} +func BackfillingCheckpointMarkerFromVTPool() *BackfillingCheckpointMarker { + return vtprotoPool_BackfillingCheckpointMarker.Get().(*BackfillingCheckpointMarker) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockVoluntaryExit = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockVoluntaryExit{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockVoluntaryExit) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockVoluntaryExit) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockVoluntaryExit.Put(m) + } +} +func CannonLocationEthV2BeaconBlockVoluntaryExitFromVTPool() *CannonLocationEthV2BeaconBlockVoluntaryExit { + return vtprotoPool_CannonLocationEthV2BeaconBlockVoluntaryExit.Get().(*CannonLocationEthV2BeaconBlockVoluntaryExit) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockProposerSlashing = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockProposerSlashing{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockProposerSlashing) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockProposerSlashing) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockProposerSlashing.Put(m) + } +} +func CannonLocationEthV2BeaconBlockProposerSlashingFromVTPool() *CannonLocationEthV2BeaconBlockProposerSlashing { + return vtprotoPool_CannonLocationEthV2BeaconBlockProposerSlashing.Get().(*CannonLocationEthV2BeaconBlockProposerSlashing) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockDeposit = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockDeposit{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockDeposit) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockDeposit) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockDeposit.Put(m) + } +} +func CannonLocationEthV2BeaconBlockDepositFromVTPool() *CannonLocationEthV2BeaconBlockDeposit { + return vtprotoPool_CannonLocationEthV2BeaconBlockDeposit.Get().(*CannonLocationEthV2BeaconBlockDeposit) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockAttesterSlashing = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockAttesterSlashing{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockAttesterSlashing) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockAttesterSlashing) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockAttesterSlashing.Put(m) + } +} +func CannonLocationEthV2BeaconBlockAttesterSlashingFromVTPool() *CannonLocationEthV2BeaconBlockAttesterSlashing { + return vtprotoPool_CannonLocationEthV2BeaconBlockAttesterSlashing.Get().(*CannonLocationEthV2BeaconBlockAttesterSlashing) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockBlsToExecutionChange = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockBlsToExecutionChange{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockBlsToExecutionChange) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockBlsToExecutionChange) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockBlsToExecutionChange.Put(m) + } +} +func CannonLocationEthV2BeaconBlockBlsToExecutionChangeFromVTPool() *CannonLocationEthV2BeaconBlockBlsToExecutionChange { + return vtprotoPool_CannonLocationEthV2BeaconBlockBlsToExecutionChange.Get().(*CannonLocationEthV2BeaconBlockBlsToExecutionChange) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockExecutionTransaction = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockExecutionTransaction{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockExecutionTransaction) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockExecutionTransaction) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockExecutionTransaction.Put(m) + } +} +func CannonLocationEthV2BeaconBlockExecutionTransactionFromVTPool() *CannonLocationEthV2BeaconBlockExecutionTransaction { + return vtprotoPool_CannonLocationEthV2BeaconBlockExecutionTransaction.Get().(*CannonLocationEthV2BeaconBlockExecutionTransaction) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockWithdrawal = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockWithdrawal{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockWithdrawal) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockWithdrawal) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockWithdrawal.Put(m) + } +} +func CannonLocationEthV2BeaconBlockWithdrawalFromVTPool() *CannonLocationEthV2BeaconBlockWithdrawal { + return vtprotoPool_CannonLocationEthV2BeaconBlockWithdrawal.Get().(*CannonLocationEthV2BeaconBlockWithdrawal) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlock = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlock{} + }, +} + +func (m *CannonLocationEthV2BeaconBlock) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlock) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlock.Put(m) + } +} +func CannonLocationEthV2BeaconBlockFromVTPool() *CannonLocationEthV2BeaconBlock { + return vtprotoPool_CannonLocationEthV2BeaconBlock.Get().(*CannonLocationEthV2BeaconBlock) +} + +var vtprotoPool_CannonLocationEthV1BeaconBlobSidecar = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV1BeaconBlobSidecar{} + }, +} + +func (m *CannonLocationEthV1BeaconBlobSidecar) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV1BeaconBlobSidecar) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV1BeaconBlobSidecar.Put(m) + } +} +func CannonLocationEthV1BeaconBlobSidecarFromVTPool() *CannonLocationEthV1BeaconBlobSidecar { + return vtprotoPool_CannonLocationEthV1BeaconBlobSidecar.Get().(*CannonLocationEthV1BeaconBlobSidecar) +} + +var vtprotoPool_CannonLocationEthV1BeaconProposerDuty = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV1BeaconProposerDuty{} + }, +} + +func (m *CannonLocationEthV1BeaconProposerDuty) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV1BeaconProposerDuty) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV1BeaconProposerDuty.Put(m) + } +} +func CannonLocationEthV1BeaconProposerDutyFromVTPool() *CannonLocationEthV1BeaconProposerDuty { + return vtprotoPool_CannonLocationEthV1BeaconProposerDuty.Get().(*CannonLocationEthV1BeaconProposerDuty) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockElaboratedAttestation = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockElaboratedAttestation{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockElaboratedAttestation) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockElaboratedAttestation) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockElaboratedAttestation.Put(m) + } +} +func CannonLocationEthV2BeaconBlockElaboratedAttestationFromVTPool() *CannonLocationEthV2BeaconBlockElaboratedAttestation { + return vtprotoPool_CannonLocationEthV2BeaconBlockElaboratedAttestation.Get().(*CannonLocationEthV2BeaconBlockElaboratedAttestation) +} + +var vtprotoPool_CannonLocationEthV1BeaconValidators = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV1BeaconValidators{} + }, +} + +func (m *CannonLocationEthV1BeaconValidators) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV1BeaconValidators) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV1BeaconValidators.Put(m) + } +} +func CannonLocationEthV1BeaconValidatorsFromVTPool() *CannonLocationEthV1BeaconValidators { + return vtprotoPool_CannonLocationEthV1BeaconValidators.Get().(*CannonLocationEthV1BeaconValidators) +} + +var vtprotoPool_CannonLocationEthV1BeaconCommittee = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV1BeaconCommittee{} + }, +} + +func (m *CannonLocationEthV1BeaconCommittee) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV1BeaconCommittee) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV1BeaconCommittee.Put(m) + } +} +func CannonLocationEthV1BeaconCommitteeFromVTPool() *CannonLocationEthV1BeaconCommittee { + return vtprotoPool_CannonLocationEthV1BeaconCommittee.Get().(*CannonLocationEthV1BeaconCommittee) +} + +var vtprotoPool_CannonLocationEthV1BeaconSyncCommittee = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV1BeaconSyncCommittee{} + }, +} + +func (m *CannonLocationEthV1BeaconSyncCommittee) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV1BeaconSyncCommittee) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV1BeaconSyncCommittee.Put(m) + } +} +func CannonLocationEthV1BeaconSyncCommitteeFromVTPool() *CannonLocationEthV1BeaconSyncCommittee { + return vtprotoPool_CannonLocationEthV1BeaconSyncCommittee.Get().(*CannonLocationEthV1BeaconSyncCommittee) +} + +var vtprotoPool_CannonLocationEthV2BeaconBlockSyncAggregate = sync.Pool{ + New: func() interface{} { + return &CannonLocationEthV2BeaconBlockSyncAggregate{} + }, +} + +func (m *CannonLocationEthV2BeaconBlockSyncAggregate) ResetVT() { + if m != nil { + m.BackfillingCheckpointMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *CannonLocationEthV2BeaconBlockSyncAggregate) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocationEthV2BeaconBlockSyncAggregate.Put(m) + } +} +func CannonLocationEthV2BeaconBlockSyncAggregateFromVTPool() *CannonLocationEthV2BeaconBlockSyncAggregate { + return vtprotoPool_CannonLocationEthV2BeaconBlockSyncAggregate.Get().(*CannonLocationEthV2BeaconBlockSyncAggregate) +} + +var vtprotoPool_CannonLocation = sync.Pool{ + New: func() interface{} { + return &CannonLocation{} + }, +} + +func (m *CannonLocation) ResetVT() { + if m != nil { + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockVoluntaryExit); ok { + oneof.EthV2BeaconBlockVoluntaryExit.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockProposerSlashing); ok { + oneof.EthV2BeaconBlockProposerSlashing.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockDeposit); ok { + oneof.EthV2BeaconBlockDeposit.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockAttesterSlashing); ok { + oneof.EthV2BeaconBlockAttesterSlashing.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockBlsToExecutionChange); ok { + oneof.EthV2BeaconBlockBlsToExecutionChange.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockExecutionTransaction); ok { + oneof.EthV2BeaconBlockExecutionTransaction.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockWithdrawal); ok { + oneof.EthV2BeaconBlockWithdrawal.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlock); ok { + oneof.EthV2BeaconBlock.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconBlobSidecar); ok { + oneof.EthV1BeaconBlobSidecar.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconProposerDuty); ok { + oneof.EthV1BeaconProposerDuty.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockElaboratedAttestation); ok { + oneof.EthV2BeaconBlockElaboratedAttestation.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconValidators); ok { + oneof.EthV1BeaconValidators.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconCommittee); ok { + oneof.EthV1BeaconCommittee.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconSyncCommittee); ok { + oneof.EthV1BeaconSyncCommittee.ReturnToVTPool() + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockSyncAggregate); ok { + oneof.EthV2BeaconBlockSyncAggregate.ReturnToVTPool() + } + m.Reset() + } +} +func (m *CannonLocation) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CannonLocation.Put(m) + } +} +func CannonLocationFromVTPool() *CannonLocation { + return vtprotoPool_CannonLocation.Get().(*CannonLocation) +} + +var vtprotoPool_GetCannonLocationRequest = sync.Pool{ + New: func() interface{} { + return &GetCannonLocationRequest{} + }, +} + +func (m *GetCannonLocationRequest) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *GetCannonLocationRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetCannonLocationRequest.Put(m) + } +} +func GetCannonLocationRequestFromVTPool() *GetCannonLocationRequest { + return vtprotoPool_GetCannonLocationRequest.Get().(*GetCannonLocationRequest) +} + +var vtprotoPool_GetCannonLocationResponse = sync.Pool{ + New: func() interface{} { + return &GetCannonLocationResponse{} + }, +} + +func (m *GetCannonLocationResponse) ResetVT() { + if m != nil { + m.Location.ReturnToVTPool() + m.Reset() + } +} +func (m *GetCannonLocationResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetCannonLocationResponse.Put(m) + } +} +func GetCannonLocationResponseFromVTPool() *GetCannonLocationResponse { + return vtprotoPool_GetCannonLocationResponse.Get().(*GetCannonLocationResponse) +} + +var vtprotoPool_UpsertCannonLocationRequest = sync.Pool{ + New: func() interface{} { + return &UpsertCannonLocationRequest{} + }, +} + +func (m *UpsertCannonLocationRequest) ResetVT() { + if m != nil { + m.Location.ReturnToVTPool() + m.Reset() + } +} +func (m *UpsertCannonLocationRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_UpsertCannonLocationRequest.Put(m) + } +} +func UpsertCannonLocationRequestFromVTPool() *UpsertCannonLocationRequest { + return vtprotoPool_UpsertCannonLocationRequest.Get().(*UpsertCannonLocationRequest) +} + +var vtprotoPool_UpsertCannonLocationResponse = sync.Pool{ + New: func() interface{} { + return &UpsertCannonLocationResponse{} + }, +} + +func (m *UpsertCannonLocationResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *UpsertCannonLocationResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_UpsertCannonLocationResponse.Put(m) + } +} +func UpsertCannonLocationResponseFromVTPool() *UpsertCannonLocationResponse { + return vtprotoPool_UpsertCannonLocationResponse.Get().(*UpsertCannonLocationResponse) +} + +var vtprotoPool_RelayMonitorSlotMarker = sync.Pool{ + New: func() interface{} { + return &RelayMonitorSlotMarker{} + }, +} + +func (m *RelayMonitorSlotMarker) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *RelayMonitorSlotMarker) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_RelayMonitorSlotMarker.Put(m) + } +} +func RelayMonitorSlotMarkerFromVTPool() *RelayMonitorSlotMarker { + return vtprotoPool_RelayMonitorSlotMarker.Get().(*RelayMonitorSlotMarker) +} + +var vtprotoPool_RelayMonitorLocationBidTrace = sync.Pool{ + New: func() interface{} { + return &RelayMonitorLocationBidTrace{} + }, +} + +func (m *RelayMonitorLocationBidTrace) ResetVT() { + if m != nil { + m.SlotMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *RelayMonitorLocationBidTrace) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_RelayMonitorLocationBidTrace.Put(m) + } +} +func RelayMonitorLocationBidTraceFromVTPool() *RelayMonitorLocationBidTrace { + return vtprotoPool_RelayMonitorLocationBidTrace.Get().(*RelayMonitorLocationBidTrace) +} + +var vtprotoPool_RelayMonitorLocationPayloadDelivered = sync.Pool{ + New: func() interface{} { + return &RelayMonitorLocationPayloadDelivered{} + }, +} + +func (m *RelayMonitorLocationPayloadDelivered) ResetVT() { + if m != nil { + m.SlotMarker.ReturnToVTPool() + m.Reset() + } +} +func (m *RelayMonitorLocationPayloadDelivered) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_RelayMonitorLocationPayloadDelivered.Put(m) + } +} +func RelayMonitorLocationPayloadDeliveredFromVTPool() *RelayMonitorLocationPayloadDelivered { + return vtprotoPool_RelayMonitorLocationPayloadDelivered.Get().(*RelayMonitorLocationPayloadDelivered) +} + +var vtprotoPool_RelayMonitorLocation = sync.Pool{ + New: func() interface{} { + return &RelayMonitorLocation{} + }, +} + +func (m *RelayMonitorLocation) ResetVT() { + if m != nil { + if oneof, ok := m.Data.(*RelayMonitorLocation_BidTrace); ok { + oneof.BidTrace.ReturnToVTPool() + } + if oneof, ok := m.Data.(*RelayMonitorLocation_PayloadDelivered); ok { + oneof.PayloadDelivered.ReturnToVTPool() + } + m.Reset() + } +} +func (m *RelayMonitorLocation) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_RelayMonitorLocation.Put(m) + } +} +func RelayMonitorLocationFromVTPool() *RelayMonitorLocation { + return vtprotoPool_RelayMonitorLocation.Get().(*RelayMonitorLocation) +} + +var vtprotoPool_GetRelayMonitorLocationRequest = sync.Pool{ + New: func() interface{} { + return &GetRelayMonitorLocationRequest{} + }, +} + +func (m *GetRelayMonitorLocationRequest) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *GetRelayMonitorLocationRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetRelayMonitorLocationRequest.Put(m) + } +} +func GetRelayMonitorLocationRequestFromVTPool() *GetRelayMonitorLocationRequest { + return vtprotoPool_GetRelayMonitorLocationRequest.Get().(*GetRelayMonitorLocationRequest) +} + +var vtprotoPool_GetRelayMonitorLocationResponse = sync.Pool{ + New: func() interface{} { + return &GetRelayMonitorLocationResponse{} + }, +} + +func (m *GetRelayMonitorLocationResponse) ResetVT() { + if m != nil { + m.Location.ReturnToVTPool() + m.Reset() + } +} +func (m *GetRelayMonitorLocationResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_GetRelayMonitorLocationResponse.Put(m) + } +} +func GetRelayMonitorLocationResponseFromVTPool() *GetRelayMonitorLocationResponse { + return vtprotoPool_GetRelayMonitorLocationResponse.Get().(*GetRelayMonitorLocationResponse) +} + +var vtprotoPool_UpsertRelayMonitorLocationRequest = sync.Pool{ + New: func() interface{} { + return &UpsertRelayMonitorLocationRequest{} + }, +} + +func (m *UpsertRelayMonitorLocationRequest) ResetVT() { + if m != nil { + m.Location.ReturnToVTPool() + m.Reset() + } +} +func (m *UpsertRelayMonitorLocationRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_UpsertRelayMonitorLocationRequest.Put(m) + } +} +func UpsertRelayMonitorLocationRequestFromVTPool() *UpsertRelayMonitorLocationRequest { + return vtprotoPool_UpsertRelayMonitorLocationRequest.Get().(*UpsertRelayMonitorLocationRequest) +} + +var vtprotoPool_UpsertRelayMonitorLocationResponse = sync.Pool{ + New: func() interface{} { + return &UpsertRelayMonitorLocationResponse{} + }, +} + +func (m *UpsertRelayMonitorLocationResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *UpsertRelayMonitorLocationResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_UpsertRelayMonitorLocationResponse.Put(m) + } +} +func UpsertRelayMonitorLocationResponseFromVTPool() *UpsertRelayMonitorLocationResponse { + return vtprotoPool_UpsertRelayMonitorLocationResponse.Get().(*UpsertRelayMonitorLocationResponse) +} +func (m *CreateNodeRecordsRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NodeRecords) > 0 { + for _, s := range m.NodeRecords { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *CreateNodeRecordsResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *ListStalledExecutionNodeRecordsRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PageSize != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.PageSize)) + } + n += len(m.unknownFields) + return n +} + +func (m *ListStalledExecutionNodeRecordsResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NodeRecords) > 0 { + for _, s := range m.NodeRecords { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionNodeStatus_Capability) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Version != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Version)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionNodeStatus_ForkID) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Next != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Next)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionNodeStatus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NodeRecord) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Capabilities) > 0 { + for _, e := range m.Capabilities { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ProtocolVersion != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProtocolVersion)) + } + if m.NetworkId != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.NetworkId)) + } + l = len(m.TotalDifficulty) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Head) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Genesis) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ForkId != nil { + l = m.ForkId.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CreateExecutionNodeRecordStatusRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Status != nil { + l = m.Status.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CreateExecutionNodeRecordStatusResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *CoordinatedNodeRecord) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NodeRecord) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Connected { + n += 2 + } + if m.ConnectionAttempts != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ConnectionAttempts)) + } + n += len(m.unknownFields) + return n +} + +func (m *CoordinateExecutionNodeRecordsRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NodeRecords) > 0 { + for _, e := range m.NodeRecords { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Limit != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Limit)) + } + if len(m.NetworkIds) > 0 { + l = 0 + for _, e := range m.NetworkIds { + l += protohelpers.SizeOfVarint(uint64(e)) + } + n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l + } + if len(m.ForkIdHashes) > 0 { + for _, b := range m.ForkIdHashes { + l = len(b) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + l = len(m.ClientId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Capabilities) > 0 { + for _, s := range m.Capabilities { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *CoordinateExecutionNodeRecordsResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NodeRecords) > 0 { + for _, s := range m.NodeRecords { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.RetryDelay != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.RetryDelay)) + } + n += len(m.unknownFields) + return n +} + +func (m *ConsensusNodeStatus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NodeRecord) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ForkDigest) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.NextForkDigest) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FinalizedRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.FinalizedEpoch) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedEpochStartDateTime != nil { + l = (*timestamppb.Timestamp)(m.FinalizedEpochStartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.HeadRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.HeadSlot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HeadSlotStartDateTime != nil { + l = (*timestamppb.Timestamp)(m.HeadSlotStartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Cgc) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.NetworkId != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.NetworkId)) + } + l = len(m.NodeId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PeerId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ListStalledConsensusNodeRecordsRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PageSize != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.PageSize)) + } + n += len(m.unknownFields) + return n +} + +func (m *ListStalledConsensusNodeRecordsResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NodeRecords) > 0 { + for _, s := range m.NodeRecords { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *CreateConsensusNodeRecordStatusRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Status != nil { + l = m.Status.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CreateConsensusNodeRecordStatusResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *CreateConsensusNodeRecordStatusesRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Statuses) > 0 { + for _, e := range m.Statuses { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *CreateConsensusNodeRecordStatusesResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *CoordinateConsensusNodeRecordsRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NodeRecords) > 0 { + for _, e := range m.NodeRecords { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Limit != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Limit)) + } + if len(m.NetworkIds) > 0 { + l = 0 + for _, e := range m.NetworkIds { + l += protohelpers.SizeOfVarint(uint64(e)) + } + n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l + } + if len(m.ForkIdHashes) > 0 { + for _, b := range m.ForkIdHashes { + l = len(b) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + l = len(m.ClientId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Capabilities) > 0 { + for _, s := range m.Capabilities { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *CoordinateConsensusNodeRecordsResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NodeRecords) > 0 { + for _, s := range m.NodeRecords { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.RetryDelay != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.RetryDelay)) + } + n += len(m.unknownFields) + return n +} + +func (m *GetDiscoveryNodeRecordRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NetworkIds) > 0 { + l = 0 + for _, e := range m.NetworkIds { + l += protohelpers.SizeOfVarint(uint64(e)) + } + n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l + } + if len(m.ForkIdHashes) > 0 { + for _, b := range m.ForkIdHashes { + l = len(b) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *GetDiscoveryNodeRecordResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NodeRecord) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *GetDiscoveryExecutionNodeRecordRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NetworkIds) > 0 { + l = 0 + for _, e := range m.NetworkIds { + l += protohelpers.SizeOfVarint(uint64(e)) + } + n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l + } + if len(m.ForkIdHashes) > 0 { + for _, b := range m.ForkIdHashes { + l = len(b) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *GetDiscoveryExecutionNodeRecordResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NodeRecord) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *GetDiscoveryConsensusNodeRecordRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NetworkIds) > 0 { + l = 0 + for _, e := range m.NetworkIds { + l += protohelpers.SizeOfVarint(uint64(e)) + } + n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l + } + if len(m.ForkDigests) > 0 { + for _, b := range m.ForkDigests { + l = len(b) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *GetDiscoveryConsensusNodeRecordResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NodeRecord) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BackfillingCheckpointMarker) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FinalizedEpoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.FinalizedEpoch)) + } + if m.BackfillEpoch != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BackfillEpoch)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockVoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockProposerSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockDeposit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockAttesterSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockBlsToExecutionChange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockExecutionTransaction) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockWithdrawal) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV1BeaconBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV1BeaconProposerDuty) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockElaboratedAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV1BeaconValidators) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV1BeaconCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV1BeaconSyncCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocationEthV2BeaconBlockSyncAggregate) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BackfillingCheckpointMarker != nil { + l = m.BackfillingCheckpointMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NetworkId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Type != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Type)) + } + if vtmsg, ok := m.Data.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *CannonLocation_EthV2BeaconBlockVoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockVoluntaryExit != nil { + l = m.EthV2BeaconBlockVoluntaryExit.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlockProposerSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockProposerSlashing != nil { + l = m.EthV2BeaconBlockProposerSlashing.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlockDeposit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockDeposit != nil { + l = m.EthV2BeaconBlockDeposit.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlockAttesterSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockAttesterSlashing != nil { + l = m.EthV2BeaconBlockAttesterSlashing.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlockBlsToExecutionChange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockBlsToExecutionChange != nil { + l = m.EthV2BeaconBlockBlsToExecutionChange.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlockExecutionTransaction) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockExecutionTransaction != nil { + l = m.EthV2BeaconBlockExecutionTransaction.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlockWithdrawal) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockWithdrawal != nil { + l = m.EthV2BeaconBlockWithdrawal.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlock != nil { + l = m.EthV2BeaconBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV1BeaconBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconBlobSidecar != nil { + l = m.EthV1BeaconBlobSidecar.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV1BeaconProposerDuty) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconProposerDuty != nil { + l = m.EthV1BeaconProposerDuty.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlockElaboratedAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockElaboratedAttestation != nil { + l = m.EthV2BeaconBlockElaboratedAttestation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV1BeaconValidators) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconValidators != nil { + l = m.EthV1BeaconValidators.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV1BeaconCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconCommittee != nil { + l = m.EthV1BeaconCommittee.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV1BeaconSyncCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconSyncCommittee != nil { + l = m.EthV1BeaconSyncCommittee.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CannonLocation_EthV2BeaconBlockSyncAggregate) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockSyncAggregate != nil { + l = m.EthV2BeaconBlockSyncAggregate.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *GetCannonLocationRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NetworkId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Type != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Type)) + } + n += len(m.unknownFields) + return n +} + +func (m *GetCannonLocationResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Location != nil { + l = m.Location.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UpsertCannonLocationRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Location != nil { + l = m.Location.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UpsertCannonLocationResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *RelayMonitorSlotMarker) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CurrentSlot != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.CurrentSlot)) + } + n += len(m.unknownFields) + return n +} + +func (m *RelayMonitorLocationBidTrace) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SlotMarker != nil { + l = m.SlotMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *RelayMonitorLocationPayloadDelivered) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SlotMarker != nil { + l = m.SlotMarker.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *RelayMonitorLocation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.MetaNetworkName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.MetaClientName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.RelayName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Type != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Type)) + } + if vtmsg, ok := m.Data.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *RelayMonitorLocation_BidTrace) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BidTrace != nil { + l = m.BidTrace.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *RelayMonitorLocation_PayloadDelivered) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PayloadDelivered != nil { + l = m.PayloadDelivered.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *GetRelayMonitorLocationRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.MetaNetworkName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.MetaClientName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.RelayName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Type != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Type)) + } + n += len(m.unknownFields) + return n +} + +func (m *GetRelayMonitorLocationResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Location != nil { + l = m.Location.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UpsertRelayMonitorLocationRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Location != nil { + l = m.Location.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UpsertRelayMonitorLocationResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *CreateNodeRecordsRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateNodeRecordsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateNodeRecordsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecords", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecords = append(m.NodeRecords, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CreateNodeRecordsResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateNodeRecordsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateNodeRecordsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ListStalledExecutionNodeRecordsRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ListStalledExecutionNodeRecordsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ListStalledExecutionNodeRecordsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PageSize", wireType) + } + m.PageSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PageSize |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ListStalledExecutionNodeRecordsResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ListStalledExecutionNodeRecordsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ListStalledExecutionNodeRecordsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecords", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecords = append(m.NodeRecords, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionNodeStatus_Capability) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionNodeStatus_Capability: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionNodeStatus_Capability: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionNodeStatus_ForkID) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionNodeStatus_ForkID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionNodeStatus_ForkID: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Next", wireType) + } + m.Next = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Next |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionNodeStatus) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionNodeStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionNodeStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecord", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecord = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Capabilities", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Capabilities) == cap(m.Capabilities) { + m.Capabilities = append(m.Capabilities, &ExecutionNodeStatus_Capability{}) + } else { + m.Capabilities = m.Capabilities[:len(m.Capabilities)+1] + if m.Capabilities[len(m.Capabilities)-1] == nil { + m.Capabilities[len(m.Capabilities)-1] = &ExecutionNodeStatus_Capability{} + } + } + if err := m.Capabilities[len(m.Capabilities)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProtocolVersion", wireType) + } + m.ProtocolVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProtocolVersion |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkId", wireType) + } + m.NetworkId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NetworkId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalDifficulty", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TotalDifficulty = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Head", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Head = append(m.Head[:0], dAtA[iNdEx:postIndex]...) + if m.Head == nil { + m.Head = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Genesis", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Genesis = append(m.Genesis[:0], dAtA[iNdEx:postIndex]...) + if m.Genesis == nil { + m.Genesis = []byte{} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ForkId == nil { + m.ForkId = ExecutionNodeStatus_ForkIDFromVTPool() + } + if err := m.ForkId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CreateExecutionNodeRecordStatusRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateExecutionNodeRecordStatusRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateExecutionNodeRecordStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Status == nil { + m.Status = ExecutionNodeStatusFromVTPool() + } + if err := m.Status.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CreateExecutionNodeRecordStatusResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateExecutionNodeRecordStatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateExecutionNodeRecordStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinatedNodeRecord) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CoordinatedNodeRecord: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CoordinatedNodeRecord: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecord", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecord = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Connected", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Connected = bool(v != 0) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionAttempts", wireType) + } + m.ConnectionAttempts = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ConnectionAttempts |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinateExecutionNodeRecordsRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CoordinateExecutionNodeRecordsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CoordinateExecutionNodeRecordsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecords", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.NodeRecords) == cap(m.NodeRecords) { + m.NodeRecords = append(m.NodeRecords, &CoordinatedNodeRecord{}) + } else { + m.NodeRecords = m.NodeRecords[:len(m.NodeRecords)+1] + if m.NodeRecords[len(m.NodeRecords)-1] == nil { + m.NodeRecords[len(m.NodeRecords)-1] = &CoordinatedNodeRecord{} + } + } + if err := m.NodeRecords[len(m.NodeRecords)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) + } + m.Limit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Limit |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.NetworkIds) == 0 && cap(m.NetworkIds) < elementCount { + m.NetworkIds = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkIds", wireType) + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkIdHashes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ForkIdHashes = append(m.ForkIdHashes, make([]byte, postIndex-iNdEx)) + copy(m.ForkIdHashes[len(m.ForkIdHashes)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Capabilities", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Capabilities = append(m.Capabilities, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinateExecutionNodeRecordsResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CoordinateExecutionNodeRecordsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CoordinateExecutionNodeRecordsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecords", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecords = append(m.NodeRecords, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RetryDelay", wireType) + } + m.RetryDelay = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RetryDelay |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConsensusNodeStatus) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConsensusNodeStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConsensusNodeStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecord", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecord = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkDigest", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ForkDigest = append(m.ForkDigest[:0], dAtA[iNdEx:postIndex]...) + if m.ForkDigest == nil { + m.ForkDigest = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NextForkDigest", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NextForkDigest = append(m.NextForkDigest[:0], dAtA[iNdEx:postIndex]...) + if m.NextForkDigest == nil { + m.NextForkDigest = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedRoot", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FinalizedRoot = append(m.FinalizedRoot[:0], dAtA[iNdEx:postIndex]...) + if m.FinalizedRoot == nil { + m.FinalizedRoot = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpoch", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FinalizedEpoch = append(m.FinalizedEpoch[:0], dAtA[iNdEx:postIndex]...) + if m.FinalizedEpoch == nil { + m.FinalizedEpoch = []byte{} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpochStartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedEpochStartDateTime == nil { + m.FinalizedEpochStartDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.FinalizedEpochStartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadRoot", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.HeadRoot = append(m.HeadRoot[:0], dAtA[iNdEx:postIndex]...) + if m.HeadRoot == nil { + m.HeadRoot = []byte{} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadSlot", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.HeadSlot = append(m.HeadSlot[:0], dAtA[iNdEx:postIndex]...) + if m.HeadSlot == nil { + m.HeadSlot = []byte{} + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadSlotStartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeadSlotStartDateTime == nil { + m.HeadSlotStartDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.HeadSlotStartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cgc", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Cgc = append(m.Cgc[:0], dAtA[iNdEx:postIndex]...) + if m.Cgc == nil { + m.Cgc = []byte{} + } + iNdEx = postIndex + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkId", wireType) + } + m.NetworkId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NetworkId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ListStalledConsensusNodeRecordsRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ListStalledConsensusNodeRecordsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ListStalledConsensusNodeRecordsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PageSize", wireType) + } + m.PageSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PageSize |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ListStalledConsensusNodeRecordsResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ListStalledConsensusNodeRecordsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ListStalledConsensusNodeRecordsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecords", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecords = append(m.NodeRecords, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CreateConsensusNodeRecordStatusRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateConsensusNodeRecordStatusRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateConsensusNodeRecordStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Status == nil { + m.Status = ConsensusNodeStatusFromVTPool() + } + if err := m.Status.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CreateConsensusNodeRecordStatusResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateConsensusNodeRecordStatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateConsensusNodeRecordStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CreateConsensusNodeRecordStatusesRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateConsensusNodeRecordStatusesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateConsensusNodeRecordStatusesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Statuses) == cap(m.Statuses) { + m.Statuses = append(m.Statuses, &ConsensusNodeStatus{}) + } else { + m.Statuses = m.Statuses[:len(m.Statuses)+1] + if m.Statuses[len(m.Statuses)-1] == nil { + m.Statuses[len(m.Statuses)-1] = &ConsensusNodeStatus{} + } + } + if err := m.Statuses[len(m.Statuses)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CreateConsensusNodeRecordStatusesResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateConsensusNodeRecordStatusesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateConsensusNodeRecordStatusesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinateConsensusNodeRecordsRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CoordinateConsensusNodeRecordsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CoordinateConsensusNodeRecordsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecords", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.NodeRecords) == cap(m.NodeRecords) { + m.NodeRecords = append(m.NodeRecords, &CoordinatedNodeRecord{}) + } else { + m.NodeRecords = m.NodeRecords[:len(m.NodeRecords)+1] + if m.NodeRecords[len(m.NodeRecords)-1] == nil { + m.NodeRecords[len(m.NodeRecords)-1] = &CoordinatedNodeRecord{} + } + } + if err := m.NodeRecords[len(m.NodeRecords)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) + } + m.Limit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Limit |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.NetworkIds) == 0 && cap(m.NetworkIds) < elementCount { + m.NetworkIds = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkIds", wireType) + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkIdHashes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ForkIdHashes = append(m.ForkIdHashes, make([]byte, postIndex-iNdEx)) + copy(m.ForkIdHashes[len(m.ForkIdHashes)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Capabilities", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Capabilities = append(m.Capabilities, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CoordinateConsensusNodeRecordsResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CoordinateConsensusNodeRecordsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CoordinateConsensusNodeRecordsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecords", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecords = append(m.NodeRecords, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RetryDelay", wireType) + } + m.RetryDelay = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RetryDelay |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetDiscoveryNodeRecordRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetDiscoveryNodeRecordRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetDiscoveryNodeRecordRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.NetworkIds) == 0 && cap(m.NetworkIds) < elementCount { + m.NetworkIds = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkIds", wireType) + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkIdHashes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ForkIdHashes = append(m.ForkIdHashes, make([]byte, postIndex-iNdEx)) + copy(m.ForkIdHashes[len(m.ForkIdHashes)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetDiscoveryNodeRecordResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetDiscoveryNodeRecordResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetDiscoveryNodeRecordResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecord", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecord = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetDiscoveryExecutionNodeRecordRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetDiscoveryExecutionNodeRecordRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetDiscoveryExecutionNodeRecordRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.NetworkIds) == 0 && cap(m.NetworkIds) < elementCount { + m.NetworkIds = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkIds", wireType) + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkIdHashes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ForkIdHashes = append(m.ForkIdHashes, make([]byte, postIndex-iNdEx)) + copy(m.ForkIdHashes[len(m.ForkIdHashes)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetDiscoveryExecutionNodeRecordResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetDiscoveryExecutionNodeRecordResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetDiscoveryExecutionNodeRecordResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecord", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecord = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetDiscoveryConsensusNodeRecordRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetDiscoveryConsensusNodeRecordRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetDiscoveryConsensusNodeRecordRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.NetworkIds) == 0 && cap(m.NetworkIds) < elementCount { + m.NetworkIds = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NetworkIds = append(m.NetworkIds, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkIds", wireType) + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkDigests", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ForkDigests = append(m.ForkDigests, make([]byte, postIndex-iNdEx)) + copy(m.ForkDigests[len(m.ForkDigests)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetDiscoveryConsensusNodeRecordResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetDiscoveryConsensusNodeRecordResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetDiscoveryConsensusNodeRecordResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecord", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NodeRecord = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BackfillingCheckpointMarker) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BackfillingCheckpointMarker: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BackfillingCheckpointMarker: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpoch", wireType) + } + m.FinalizedEpoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FinalizedEpoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillEpoch", wireType) + } + m.BackfillEpoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BackfillEpoch |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockVoluntaryExit) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockVoluntaryExit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockVoluntaryExit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockProposerSlashing) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockProposerSlashing: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockProposerSlashing: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockDeposit) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockDeposit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockDeposit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockAttesterSlashing) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockAttesterSlashing: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockAttesterSlashing: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockBlsToExecutionChange) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockBlsToExecutionChange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockBlsToExecutionChange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockExecutionTransaction) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockExecutionTransaction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockExecutionTransaction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockWithdrawal) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockWithdrawal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockWithdrawal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlock) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV1BeaconBlobSidecar) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconBlobSidecar: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconBlobSidecar: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV1BeaconProposerDuty) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconProposerDuty: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconProposerDuty: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockElaboratedAttestation) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockElaboratedAttestation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockElaboratedAttestation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV1BeaconValidators) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconValidators: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconValidators: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV1BeaconCommittee) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconCommittee: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconCommittee: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV1BeaconSyncCommittee) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconSyncCommittee: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV1BeaconSyncCommittee: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocationEthV2BeaconBlockSyncAggregate) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockSyncAggregate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocationEthV2BeaconBlockSyncAggregate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackfillingCheckpointMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BackfillingCheckpointMarker == nil { + m.BackfillingCheckpointMarker = BackfillingCheckpointMarkerFromVTPool() + } + if err := m.BackfillingCheckpointMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CannonLocation) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CannonLocation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CannonLocation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NetworkId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= CannonType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockVoluntaryExit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockVoluntaryExit); ok { + if err := oneof.EthV2BeaconBlockVoluntaryExit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockVoluntaryExitFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockVoluntaryExit{EthV2BeaconBlockVoluntaryExit: v} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockProposerSlashing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockProposerSlashing); ok { + if err := oneof.EthV2BeaconBlockProposerSlashing.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockProposerSlashingFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockProposerSlashing{EthV2BeaconBlockProposerSlashing: v} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockDeposit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockDeposit); ok { + if err := oneof.EthV2BeaconBlockDeposit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockDepositFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockDeposit{EthV2BeaconBlockDeposit: v} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockAttesterSlashing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockAttesterSlashing); ok { + if err := oneof.EthV2BeaconBlockAttesterSlashing.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockAttesterSlashingFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockAttesterSlashing{EthV2BeaconBlockAttesterSlashing: v} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockBlsToExecutionChange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockBlsToExecutionChange); ok { + if err := oneof.EthV2BeaconBlockBlsToExecutionChange.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockBlsToExecutionChangeFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockBlsToExecutionChange{EthV2BeaconBlockBlsToExecutionChange: v} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockExecutionTransaction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockExecutionTransaction); ok { + if err := oneof.EthV2BeaconBlockExecutionTransaction.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockExecutionTransactionFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockExecutionTransaction{EthV2BeaconBlockExecutionTransaction: v} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockWithdrawal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockWithdrawal); ok { + if err := oneof.EthV2BeaconBlockWithdrawal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockWithdrawalFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockWithdrawal{EthV2BeaconBlockWithdrawal: v} + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlock); ok { + if err := oneof.EthV2BeaconBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlock{EthV2BeaconBlock: v} + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconBlobSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconBlobSidecar); ok { + if err := oneof.EthV1BeaconBlobSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV1BeaconBlobSidecarFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV1BeaconBlobSidecar{EthV1BeaconBlobSidecar: v} + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconProposerDuty", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconProposerDuty); ok { + if err := oneof.EthV1BeaconProposerDuty.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV1BeaconProposerDutyFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV1BeaconProposerDuty{EthV1BeaconProposerDuty: v} + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockElaboratedAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockElaboratedAttestation); ok { + if err := oneof.EthV2BeaconBlockElaboratedAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockElaboratedAttestationFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockElaboratedAttestation{EthV2BeaconBlockElaboratedAttestation: v} + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconValidators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconValidators); ok { + if err := oneof.EthV1BeaconValidators.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV1BeaconValidatorsFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV1BeaconValidators{EthV1BeaconValidators: v} + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconCommittee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconCommittee); ok { + if err := oneof.EthV1BeaconCommittee.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV1BeaconCommitteeFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV1BeaconCommittee{EthV1BeaconCommittee: v} + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconSyncCommittee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV1BeaconSyncCommittee); ok { + if err := oneof.EthV1BeaconSyncCommittee.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV1BeaconSyncCommitteeFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV1BeaconSyncCommittee{EthV1BeaconSyncCommittee: v} + } + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockSyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*CannonLocation_EthV2BeaconBlockSyncAggregate); ok { + if err := oneof.EthV2BeaconBlockSyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := CannonLocationEthV2BeaconBlockSyncAggregateFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &CannonLocation_EthV2BeaconBlockSyncAggregate{EthV2BeaconBlockSyncAggregate: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetCannonLocationRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetCannonLocationRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetCannonLocationRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NetworkId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= CannonType(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetCannonLocationResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetCannonLocationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetCannonLocationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Location == nil { + m.Location = CannonLocationFromVTPool() + } + if err := m.Location.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpsertCannonLocationRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpsertCannonLocationRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpsertCannonLocationRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Location == nil { + m.Location = CannonLocationFromVTPool() + } + if err := m.Location.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpsertCannonLocationResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpsertCannonLocationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpsertCannonLocationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RelayMonitorSlotMarker) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RelayMonitorSlotMarker: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RelayMonitorSlotMarker: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentSlot", wireType) + } + m.CurrentSlot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CurrentSlot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RelayMonitorLocationBidTrace) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RelayMonitorLocationBidTrace: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RelayMonitorLocationBidTrace: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SlotMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SlotMarker == nil { + m.SlotMarker = RelayMonitorSlotMarkerFromVTPool() + } + if err := m.SlotMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RelayMonitorLocationPayloadDelivered) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RelayMonitorLocationPayloadDelivered: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RelayMonitorLocationPayloadDelivered: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SlotMarker", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SlotMarker == nil { + m.SlotMarker = RelayMonitorSlotMarkerFromVTPool() + } + if err := m.SlotMarker.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RelayMonitorLocation) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RelayMonitorLocation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RelayMonitorLocation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetaNetworkName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetaNetworkName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetaClientName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetaClientName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RelayName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RelayName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= RelayMonitorType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BidTrace", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*RelayMonitorLocation_BidTrace); ok { + if err := oneof.BidTrace.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := RelayMonitorLocationBidTraceFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &RelayMonitorLocation_BidTrace{BidTrace: v} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PayloadDelivered", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*RelayMonitorLocation_PayloadDelivered); ok { + if err := oneof.PayloadDelivered.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := RelayMonitorLocationPayloadDeliveredFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &RelayMonitorLocation_PayloadDelivered{PayloadDelivered: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetRelayMonitorLocationRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetRelayMonitorLocationRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetRelayMonitorLocationRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetaNetworkName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetaNetworkName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetaClientName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetaClientName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RelayName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RelayName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= RelayMonitorType(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetRelayMonitorLocationResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetRelayMonitorLocationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetRelayMonitorLocationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Location == nil { + m.Location = RelayMonitorLocationFromVTPool() + } + if err := m.Location.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpsertRelayMonitorLocationRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpsertRelayMonitorLocationRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpsertRelayMonitorLocationRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Location == nil { + m.Location = RelayMonitorLocationFromVTPool() + } + if err := m.Location.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpsertRelayMonitorLocationResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpsertRelayMonitorLocationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpsertRelayMonitorLocationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pkg/proto/xatu/event_ingester_vtproto.pb.go b/pkg/proto/xatu/event_ingester_vtproto.pb.go new file mode 100644 index 000000000..8b75f7268 --- /dev/null +++ b/pkg/proto/xatu/event_ingester_vtproto.pb.go @@ -0,0 +1,52354 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: pkg/proto/xatu/event_ingester.proto + +package xatu + +import ( + binary "encoding/binary" + fmt "fmt" + v1 "github.com/ethpandaops/xatu/pkg/proto/eth/v1" + v2 "github.com/ethpandaops/xatu/pkg/proto/eth/v2" + libp2p "github.com/ethpandaops/xatu/pkg/proto/libp2p" + gossipsub "github.com/ethpandaops/xatu/pkg/proto/libp2p/gossipsub" + mevrelay "github.com/ethpandaops/xatu/pkg/proto/mevrelay" + noderecord "github.com/ethpandaops/xatu/pkg/proto/noderecord" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + timestamppb "github.com/planetscale/vtprotobuf/types/known/timestamppb" + wrapperspb "github.com/planetscale/vtprotobuf/types/known/wrapperspb" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb1 "google.golang.org/protobuf/types/known/timestamppb" + wrapperspb1 "google.golang.org/protobuf/types/known/wrapperspb" + io "io" + math "math" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +func (m *CreateEventsRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateEventsRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateEventsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Events) > 0 { + for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Events[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CreateEventsResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CreateEventsResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CreateEventsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.EventsIngested != nil { + size, err := (*wrapperspb.UInt64Value)(m.EventsIngested).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Epoch) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Epoch) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Epoch) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.StartDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.StartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Number != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Number)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *EpochV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EpochV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *EpochV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.StartDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.StartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Number != nil { + size, err := (*wrapperspb.UInt64Value)(m.Number).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Slot) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Slot) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Slot) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.StartDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.StartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Number != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Number)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SlotV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SlotV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SlotV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.StartDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.StartDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Number != nil { + size, err := (*wrapperspb.UInt64Value)(m.Number).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ForkID) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ForkID) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ForkID) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Next) > 0 { + i -= len(m.Next) + copy(dAtA[i:], m.Next) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Next))) + i-- + dAtA[i] = 0x12 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Propagation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Propagation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Propagation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SlotStartDiff != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SlotStartDiff)) + i-- + dAtA[i] = 0x18 + } + return len(dAtA) - i, nil +} + +func (m *PropagationV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PropagationV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *PropagationV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SlotStartDiff != nil { + size, err := (*wrapperspb.UInt64Value)(m.SlotStartDiff).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AttestingValidator) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AttestingValidator) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AttestingValidator) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Index != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x10 + } + if m.CommitteeIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.CommitteeIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AttestingValidatorV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AttestingValidatorV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *AttestingValidatorV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Index != nil { + size, err := (*wrapperspb.UInt64Value)(m.Index).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.CommitteeIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.CommitteeIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DebugForkChoiceReorg) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DebugForkChoiceReorg) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DebugForkChoiceReorg) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Event != nil { + size, err := m.Event.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.After != nil { + size, err := m.After.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Before != nil { + size, err := m.Before.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DebugForkChoiceReorgV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DebugForkChoiceReorgV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DebugForkChoiceReorgV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Event != nil { + size, err := m.Event.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.After != nil { + size, err := m.After.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Before != nil { + size, err := m.Before.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Validators) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Validators) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Validators) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Validators) > 0 { + for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Validators[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *SyncCommitteeData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncCommitteeData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SyncCommitteeData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SyncCommittee != nil { + size, err := m.SyncCommittee.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SyncAggregateData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SyncAggregateData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SyncAggregateData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ParticipationCount != nil { + size, err := (*wrapperspb.UInt64Value)(m.ParticipationCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.ValidatorsMissed) > 0 { + for iNdEx := len(m.ValidatorsMissed) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorsMissed[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.ValidatorsParticipated) > 0 { + for iNdEx := len(m.ValidatorsParticipated) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorsParticipated[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.SyncCommitteeSignature) > 0 { + i -= len(m.SyncCommitteeSignature) + copy(dAtA[i:], m.SyncCommitteeSignature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SyncCommitteeSignature))) + i-- + dAtA[i] = 0x12 + } + if len(m.SyncCommitteeBits) > 0 { + i -= len(m.SyncCommitteeBits) + copy(dAtA[i:], m.SyncCommitteeBits) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SyncCommitteeBits))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlockIdentifier) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockIdentifier) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlockIdentifier) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Root) > 0 { + i -= len(m.Root) + copy(dAtA[i:], m.Root) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Root))) + i-- + dAtA[i] = 0x22 + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionStateSize) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionStateSize) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionStateSize) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Storages) > 0 { + i -= len(m.Storages) + copy(dAtA[i:], m.Storages) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Storages))) + i-- + dAtA[i] = 0x62 + } + if len(m.StorageTrienodes) > 0 { + i -= len(m.StorageTrienodes) + copy(dAtA[i:], m.StorageTrienodes) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StorageTrienodes))) + i-- + dAtA[i] = 0x5a + } + if len(m.StorageTrienodeBytes) > 0 { + i -= len(m.StorageTrienodeBytes) + copy(dAtA[i:], m.StorageTrienodeBytes) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StorageTrienodeBytes))) + i-- + dAtA[i] = 0x52 + } + if len(m.StorageBytes) > 0 { + i -= len(m.StorageBytes) + copy(dAtA[i:], m.StorageBytes) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StorageBytes))) + i-- + dAtA[i] = 0x4a + } + if len(m.StateRoot) > 0 { + i -= len(m.StateRoot) + copy(dAtA[i:], m.StateRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateRoot))) + i-- + dAtA[i] = 0x42 + } + if len(m.ContractCodes) > 0 { + i -= len(m.ContractCodes) + copy(dAtA[i:], m.ContractCodes) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContractCodes))) + i-- + dAtA[i] = 0x3a + } + if len(m.ContractCodeBytes) > 0 { + i -= len(m.ContractCodeBytes) + copy(dAtA[i:], m.ContractCodeBytes) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContractCodeBytes))) + i-- + dAtA[i] = 0x32 + } + if len(m.BlockNumber) > 0 { + i -= len(m.BlockNumber) + copy(dAtA[i:], m.BlockNumber) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockNumber))) + i-- + dAtA[i] = 0x2a + } + if len(m.Accounts) > 0 { + i -= len(m.Accounts) + copy(dAtA[i:], m.Accounts) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Accounts))) + i-- + dAtA[i] = 0x22 + } + if len(m.AccountTrienodes) > 0 { + i -= len(m.AccountTrienodes) + copy(dAtA[i:], m.AccountTrienodes) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AccountTrienodes))) + i-- + dAtA[i] = 0x1a + } + if len(m.AccountTrienodeBytes) > 0 { + i -= len(m.AccountTrienodeBytes) + copy(dAtA[i:], m.AccountTrienodeBytes) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AccountTrienodeBytes))) + i-- + dAtA[i] = 0x12 + } + if len(m.AccountBytes) > 0 { + i -= len(m.AccountBytes) + copy(dAtA[i:], m.AccountBytes) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AccountBytes))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ConsensusEngineAPINewPayload) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConsensusEngineAPINewPayload) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ConsensusEngineAPINewPayload) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.MethodVersion) > 0 { + i -= len(m.MethodVersion) + copy(dAtA[i:], m.MethodVersion) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MethodVersion))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if len(m.ValidationError) > 0 { + i -= len(m.ValidationError) + copy(dAtA[i:], m.ValidationError) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ValidationError))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if len(m.LatestValidHash) > 0 { + i -= len(m.LatestValidHash) + copy(dAtA[i:], m.LatestValidHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LatestValidHash))) + i-- + dAtA[i] = 0x7a + } + if len(m.Status) > 0 { + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x72 + } + if m.BlobCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.BlobCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if m.TxCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.TxCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0x4a + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x42 + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.ProposerIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ProposerIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if len(m.ParentBlockRoot) > 0 { + i -= len(m.ParentBlockRoot) + copy(dAtA[i:], m.ParentBlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentBlockRoot))) + i-- + dAtA[i] = 0x2a + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x22 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.DurationMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.DurationMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RequestedAt != nil { + size, err := (*timestamppb.Timestamp)(m.RequestedAt).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ConsensusEngineAPIGetBlobs) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConsensusEngineAPIGetBlobs) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ConsensusEngineAPIGetBlobs) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.MethodVersion) > 0 { + i -= len(m.MethodVersion) + copy(dAtA[i:], m.MethodVersion) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MethodVersion))) + i-- + dAtA[i] = 0x5a + } + if len(m.ErrorMessage) > 0 { + i -= len(m.ErrorMessage) + copy(dAtA[i:], m.ErrorMessage) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ErrorMessage))) + i-- + dAtA[i] = 0x52 + } + if len(m.Status) > 0 { + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x4a + } + if m.ReturnedCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.ReturnedCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if len(m.VersionedHashes) > 0 { + for iNdEx := len(m.VersionedHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.VersionedHashes[iNdEx]) + copy(dAtA[i:], m.VersionedHashes[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VersionedHashes[iNdEx]))) + i-- + dAtA[i] = 0x3a + } + } + if m.RequestedCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.RequestedCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if len(m.ParentBlockRoot) > 0 { + i -= len(m.ParentBlockRoot) + copy(dAtA[i:], m.ParentBlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentBlockRoot))) + i-- + dAtA[i] = 0x2a + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x22 + } + if m.Slot != nil { + size, err := (*wrapperspb.UInt64Value)(m.Slot).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.DurationMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.DurationMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RequestedAt != nil { + size, err := (*timestamppb.Timestamp)(m.RequestedAt).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionEngineNewPayload) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionEngineNewPayload) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionEngineNewPayload) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.MethodVersion) > 0 { + i -= len(m.MethodVersion) + copy(dAtA[i:], m.MethodVersion) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MethodVersion))) + i-- + dAtA[i] = 0x72 + } + if len(m.ValidationError) > 0 { + i -= len(m.ValidationError) + copy(dAtA[i:], m.ValidationError) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ValidationError))) + i-- + dAtA[i] = 0x6a + } + if len(m.LatestValidHash) > 0 { + i -= len(m.LatestValidHash) + copy(dAtA[i:], m.LatestValidHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LatestValidHash))) + i-- + dAtA[i] = 0x62 + } + if len(m.Status) > 0 { + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x5a + } + if m.BlobCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.BlobCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.TxCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.TxCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.GasLimit != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasLimit).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.ParentHash) > 0 { + i -= len(m.ParentHash) + copy(dAtA[i:], m.ParentHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ParentHash))) + i-- + dAtA[i] = 0x32 + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x2a + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.DurationMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.DurationMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.RequestedAt != nil { + size, err := (*timestamppb.Timestamp)(m.RequestedAt).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Source != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Source)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ExecutionEngineGetBlobs) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionEngineGetBlobs) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionEngineGetBlobs) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ReturnedBlobIndexes) > 0 { + for iNdEx := len(m.ReturnedBlobIndexes) - 1; iNdEx >= 0; iNdEx-- { + size, err := (*wrapperspb.UInt32Value)(m.ReturnedBlobIndexes[iNdEx]).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + } + if len(m.MethodVersion) > 0 { + i -= len(m.MethodVersion) + copy(dAtA[i:], m.MethodVersion) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MethodVersion))) + i-- + dAtA[i] = 0x4a + } + if len(m.ErrorMessage) > 0 { + i -= len(m.ErrorMessage) + copy(dAtA[i:], m.ErrorMessage) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ErrorMessage))) + i-- + dAtA[i] = 0x42 + } + if len(m.Status) > 0 { + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x3a + } + if m.ReturnedCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.ReturnedCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if len(m.VersionedHashes) > 0 { + for iNdEx := len(m.VersionedHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.VersionedHashes[iNdEx]) + copy(dAtA[i:], m.VersionedHashes[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VersionedHashes[iNdEx]))) + i-- + dAtA[i] = 0x2a + } + } + if m.RequestedCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.RequestedCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.DurationMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.DurationMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.RequestedAt != nil { + size, err := (*timestamppb.Timestamp)(m.RequestedAt).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Source != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Source)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_Ethereum_Network) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_Ethereum_Network) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Ethereum_Network) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Id != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x10 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_Ethereum_Execution) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_Ethereum_Execution) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Ethereum_Execution) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.VersionPatch) > 0 { + i -= len(m.VersionPatch) + copy(dAtA[i:], m.VersionPatch) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VersionPatch))) + i-- + dAtA[i] = 0x32 + } + if len(m.VersionMinor) > 0 { + i -= len(m.VersionMinor) + copy(dAtA[i:], m.VersionMinor) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VersionMinor))) + i-- + dAtA[i] = 0x2a + } + if len(m.VersionMajor) > 0 { + i -= len(m.VersionMajor) + copy(dAtA[i:], m.VersionMajor) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VersionMajor))) + i-- + dAtA[i] = 0x22 + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x1a + } + if len(m.Implementation) > 0 { + i -= len(m.Implementation) + copy(dAtA[i:], m.Implementation) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Implementation))) + i-- + dAtA[i] = 0x12 + } + if m.ForkId != nil { + size, err := m.ForkId.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_Ethereum_Consensus) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_Ethereum_Consensus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Ethereum_Consensus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x12 + } + if len(m.Implementation) > 0 { + i -= len(m.Implementation) + copy(dAtA[i:], m.Implementation) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Implementation))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_Ethereum) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_Ethereum) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Ethereum) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Consensus != nil { + size, err := m.Consensus.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Execution != nil { + size, err := m.Execution.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Network != nil { + size, err := m.Network.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.AttestingValidator != nil { + size, err := m.AttestingValidator.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Target != nil { + size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.AttestingValidator != nil { + size, err := m.AttestingValidator.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Target != nil { + size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockGossipData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockGossipData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockGossipData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Contribution != nil { + size, err := m.Contribution.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Contribution != nil { + size, err := m.Contribution.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_ForkChoiceSnapshot) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_ForkChoiceSnapshot) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_ForkChoiceSnapshot) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Timestamp != nil { + size, err := (*timestamppb.Timestamp)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.RequestDurationMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RequestDurationMs)) + i-- + dAtA[i] = 0x20 + } + if m.RequestedAtSlotStartDiffMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RequestedAtSlotStartDiffMs)) + i-- + dAtA[i] = 0x18 + } + if m.RequestSlot != nil { + size, err := m.RequestSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RequestEpoch != nil { + size, err := m.RequestEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_ForkChoiceSnapshotV2) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_ForkChoiceSnapshotV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_ForkChoiceSnapshotV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Timestamp != nil { + size, err := (*timestamppb.Timestamp)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.RequestDurationMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.RequestDurationMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.RequestedAtSlotStartDiffMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.RequestedAtSlotStartDiffMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.RequestSlot != nil { + size, err := m.RequestSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RequestEpoch != nil { + size, err := m.RequestEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Snapshot != nil { + size, err := m.Snapshot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Snapshot != nil { + size, err := m.Snapshot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.After != nil { + size, err := m.After.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Before != nil { + size, err := m.Before.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.After != nil { + size, err := m.After.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Before != nil { + size, err := m.Before.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1BeaconCommitteeData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1BeaconCommitteeData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1BeaconCommitteeData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.StateId) > 0 { + i -= len(m.StateId) + copy(dAtA[i:], m.StateId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateId))) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1BeaconSyncCommitteeData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1BeaconSyncCommitteeData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1BeaconSyncCommitteeData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SyncCommitteePeriod != nil { + size, err := (*wrapperspb.UInt64Value)(m.SyncCommitteePeriod).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SyncCommitteePeriod != nil { + size, err := (*wrapperspb.UInt64Value)(m.SyncCommitteePeriod).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalMempoolTransactionData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalMempoolTransactionData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalMempoolTransactionData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.CallDataSize) > 0 { + i -= len(m.CallDataSize) + copy(dAtA[i:], m.CallDataSize) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CallDataSize))) + i-- + dAtA[i] = 0x4a + } + if len(m.Size) > 0 { + i -= len(m.Size) + copy(dAtA[i:], m.Size) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Size))) + i-- + dAtA[i] = 0x42 + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x3a + } + if m.Gas != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Gas)) + i-- + dAtA[i] = 0x30 + } + if len(m.GasPrice) > 0 { + i -= len(m.GasPrice) + copy(dAtA[i:], m.GasPrice) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GasPrice))) + i-- + dAtA[i] = 0x2a + } + if m.Nonce != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Nonce)) + i-- + dAtA[i] = 0x20 + } + if len(m.To) > 0 { + i -= len(m.To) + copy(dAtA[i:], m.To) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.To))) + i-- + dAtA[i] = 0x1a + } + if len(m.From) > 0 { + i -= len(m.From) + copy(dAtA[i:], m.From) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.From))) + i-- + dAtA[i] = 0x12 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalMempoolTransactionV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalMempoolTransactionV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalMempoolTransactionV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlobSidecarsEmptySize) > 0 { + i -= len(m.BlobSidecarsEmptySize) + copy(dAtA[i:], m.BlobSidecarsEmptySize) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobSidecarsEmptySize))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if len(m.BlobSidecarsSize) > 0 { + i -= len(m.BlobSidecarsSize) + copy(dAtA[i:], m.BlobSidecarsSize) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobSidecarsSize))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if len(m.BlobHashes) > 0 { + for iNdEx := len(m.BlobHashes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.BlobHashes[iNdEx]) + copy(dAtA[i:], m.BlobHashes[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobHashes[iNdEx]))) + i-- + dAtA[i] = 0x7a + } + } + if len(m.BlobGasFeeCap) > 0 { + i -= len(m.BlobGasFeeCap) + copy(dAtA[i:], m.BlobGasFeeCap) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobGasFeeCap))) + i-- + dAtA[i] = 0x72 + } + if m.BlobGas != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlobGas).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if len(m.GasFeeCap) > 0 { + i -= len(m.GasFeeCap) + copy(dAtA[i:], m.GasFeeCap) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GasFeeCap))) + i-- + dAtA[i] = 0x62 + } + if len(m.GasTipCap) > 0 { + i -= len(m.GasTipCap) + copy(dAtA[i:], m.GasTipCap) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GasTipCap))) + i-- + dAtA[i] = 0x5a + } + if m.Type != nil { + size, err := (*wrapperspb.UInt32Value)(m.Type).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.CallDataSize) > 0 { + i -= len(m.CallDataSize) + copy(dAtA[i:], m.CallDataSize) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CallDataSize))) + i-- + dAtA[i] = 0x4a + } + if len(m.Size) > 0 { + i -= len(m.Size) + copy(dAtA[i:], m.Size) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Size))) + i-- + dAtA[i] = 0x42 + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x3a + } + if m.Gas != nil { + size, err := (*wrapperspb.UInt64Value)(m.Gas).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if len(m.GasPrice) > 0 { + i -= len(m.GasPrice) + copy(dAtA[i:], m.GasPrice) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GasPrice))) + i-- + dAtA[i] = 0x2a + } + if m.Nonce != nil { + size, err := (*wrapperspb.UInt64Value)(m.Nonce).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.To) > 0 { + i -= len(m.To) + copy(dAtA[i:], m.To) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.To))) + i-- + dAtA[i] = 0x1a + } + if len(m.From) > 0 { + i -= len(m.From) + copy(dAtA[i:], m.From) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.From))) + i-- + dAtA[i] = 0x12 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.TransactionsTotalBytes != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TransactionsTotalBytes)) + i-- + dAtA[i] = 0x30 + } + if m.TransactionsCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TransactionsCount)) + i-- + dAtA[i] = 0x28 + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockV2Data) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockV2Data) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockV2Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.FinalizedWhenRequested { + i-- + if m.FinalizedWhenRequested { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x50 + } + if m.TotalBytesCompressed != nil { + size, err := (*wrapperspb.UInt64Value)(m.TotalBytesCompressed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.TotalBytes != nil { + size, err := (*wrapperspb.UInt64Value)(m.TotalBytes).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.TransactionsTotalBytesCompressed != nil { + size, err := (*wrapperspb.UInt64Value)(m.TransactionsTotalBytesCompressed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.TransactionsTotalBytes != nil { + size, err := (*wrapperspb.UInt64Value)(m.TransactionsTotalBytes).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.TransactionsCount != nil { + size, err := (*wrapperspb.UInt64Value)(m.TransactionsCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.BlockRoot) > 0 { + i -= len(m.BlockRoot) + copy(dAtA[i:], m.BlockRoot) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockRoot))) + i-- + dAtA[i] = 0x22 + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockDepositData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockDepositData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockDepositData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlobSidecarsEmptySize) > 0 { + i -= len(m.BlobSidecarsEmptySize) + copy(dAtA[i:], m.BlobSidecarsEmptySize) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobSidecarsEmptySize))) + i-- + dAtA[i] = 0x32 + } + if len(m.BlobSidecarsSize) > 0 { + i -= len(m.BlobSidecarsSize) + copy(dAtA[i:], m.BlobSidecarsSize) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlobSidecarsSize))) + i-- + dAtA[i] = 0x2a + } + if len(m.CallDataSize) > 0 { + i -= len(m.CallDataSize) + copy(dAtA[i:], m.CallDataSize) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CallDataSize))) + i-- + dAtA[i] = 0x22 + } + if len(m.Size) > 0 { + i -= len(m.Size) + copy(dAtA[i:], m.Size) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Size))) + i-- + dAtA[i] = 0x1a + } + if m.PositionInBlock != nil { + size, err := (*wrapperspb.UInt64Value)(m.PositionInBlock).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AttestationDataSnapshot) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AttestationDataSnapshot) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AttestationDataSnapshot) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Timestamp != nil { + size, err := (*timestamppb.Timestamp)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.RequestDurationMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.RequestDurationMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.RequestedAtSlotStartDiffMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.RequestedAtSlotStartDiffMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1ValidatorAttestationDataData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1ValidatorAttestationDataData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1ValidatorAttestationDataData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Snapshot != nil { + size, err := m.Snapshot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Target != nil { + size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsBlobSidecarData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsBlobSidecarData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsBlobSidecarData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1EventsDataColumnSidecarData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1EventsDataColumnSidecarData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1EventsDataColumnSidecarData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobSidecarData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobSidecarData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobSidecarData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.DataEmptySize != nil { + size, err := (*wrapperspb.UInt64Value)(m.DataEmptySize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.VersionedHash) > 0 { + i -= len(m.VersionedHash) + copy(dAtA[i:], m.VersionedHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VersionedHash))) + i-- + dAtA[i] = 0x22 + } + if m.DataSize != nil { + size, err := (*wrapperspb.UInt64Value)(m.DataSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalBeaconP2PAttestationData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalBeaconP2PAttestationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalBeaconP2PAttestationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Validated != nil { + size, err := (*wrapperspb.BoolValue)(m.Validated).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.Subnet != nil { + size, err := (*wrapperspb.UInt32Value)(m.Subnet).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.Peer != nil { + size, err := m.Peer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.AttestingValidator != nil { + size, err := m.AttestingValidator.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Target != nil { + size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1ProposerDutyData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1ProposerDutyData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1ProposerDutyData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.StateId) > 0 { + i -= len(m.StateId) + copy(dAtA[i:], m.StateId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateId))) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Target != nil { + size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.PositionInBlock != nil { + size, err := (*wrapperspb.UInt64Value)(m.PositionInBlock).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Block != nil { + size, err := m.Block.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceAddPeerData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceAddPeerData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceAddPeerData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRemovePeerData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRemovePeerData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRemovePeerData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRecvRPCData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRecvRPCData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRecvRPCData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceSendRPCData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceSendRPCData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceSendRPCData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceDropRPCData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceDropRPCData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceDropRPCData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceJoinData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceJoinData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceJoinData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceLeaveData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceLeaveData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceLeaveData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGraftData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGraftData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceGraftData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTracePruneData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTracePruneData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTracePruneData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceDuplicateMessageData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceDuplicateMessageData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceDuplicateMessageData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceDeliverMessageData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceDeliverMessageData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceDeliverMessageData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTracePublishMessageData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTracePublishMessageData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTracePublishMessageData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRejectMessageData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRejectMessageData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRejectMessageData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceConnectedData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceConnectedData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceConnectedData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceDisconnectedData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceDisconnectedData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceDisconnectedData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleMetadataData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleMetadataData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleMetadataData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleStatusData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleStatusData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleStatusData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceIdentifyData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceIdentifyData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceIdentifyData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.MessageSize != nil { + size, err := (*wrapperspb.UInt32Value)(m.MessageSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.MessageSize != nil { + size, err := (*wrapperspb.UInt32Value)(m.MessageSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.AttestingValidator != nil { + size, err := m.AttestingValidator.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Target != nil { + size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.MessageSize != nil { + size, err := (*wrapperspb.UInt32Value)(m.MessageSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.AggregatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.AggregatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.MessageSize != nil { + size, err := (*wrapperspb.UInt32Value)(m.MessageSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.MessageId != nil { + size, err := (*wrapperspb.StringValue)(m.MessageId).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.MessageSize != nil { + size, err := (*wrapperspb.UInt32Value)(m.MessageSize).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.Topic != nil { + size, err := (*wrapperspb.StringValue)(m.Topic).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.Metadata != nil { + size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Propagation != nil { + size, err := m.Propagation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1ValidatorsData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1ValidatorsData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1ValidatorsData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ResponseAtSlotTime != nil { + size, err := (*wrapperspb.UInt64Value)(m.ResponseAtSlotTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.RequestedAtSlotTime != nil { + size, err := (*wrapperspb.UInt64Value)(m.RequestedAtSlotTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Relay != nil { + size, err := m.Relay.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalMevRelayPayloadDeliveredData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalMevRelayPayloadDeliveredData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalMevRelayPayloadDeliveredData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ResponseAtSlotTime != nil { + size, err := (*wrapperspb.UInt64Value)(m.ResponseAtSlotTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.RequestedAtSlotTime != nil { + size, err := (*wrapperspb.UInt64Value)(m.RequestedAtSlotTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Relay != nil { + size, err := m.Relay.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV3ValidatorBlockData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV3ValidatorBlockData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV3ValidatorBlockData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.RequestedAt != nil { + size, err := (*timestamppb.Timestamp)(m.RequestedAt).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.RequestDurationMs != nil { + size, err := (*wrapperspb.UInt64Value)(m.RequestDurationMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if len(m.ConsensusValue) > 0 { + i -= len(m.ConsensusValue) + copy(dAtA[i:], m.ConsensusValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ConsensusValue))) + i-- + dAtA[i] = 0x52 + } + if len(m.ExecutionValue) > 0 { + i -= len(m.ExecutionValue) + copy(dAtA[i:], m.ExecutionValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExecutionValue))) + i-- + dAtA[i] = 0x4a + } + if m.TotalBytesCompressed != nil { + size, err := (*wrapperspb.UInt64Value)(m.TotalBytesCompressed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.TotalBytes != nil { + size, err := (*wrapperspb.UInt64Value)(m.TotalBytes).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.TransactionsTotalBytesCompressed != nil { + size, err := (*wrapperspb.UInt64Value)(m.TransactionsTotalBytesCompressed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.TransactionsTotalBytes != nil { + size, err := (*wrapperspb.UInt64Value)(m.TransactionsTotalBytes).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.TransactionsCount != nil { + size, err := (*wrapperspb.UInt64Value)(m.TransactionsCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalMevRelayValidatorRegistrationData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalMevRelayValidatorRegistrationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalMevRelayValidatorRegistrationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ValidatorIndex != nil { + size, err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.WallclockEpoch != nil { + size, err := m.WallclockEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.WallclockSlot != nil { + size, err := m.WallclockSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Relay != nil { + size, err := m.Relay.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalNodeRecordConsensusData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalNodeRecordConsensusData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalNodeRecordConsensusData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.HeadEpoch != nil { + size, err := m.HeadEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.HeadSlot != nil { + size, err := m.HeadSlot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.FinalizedEpoch != nil { + size, err := m.FinalizedEpoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalConsensusEngineAPINewPayloadData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalConsensusEngineAPINewPayloadData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalConsensusEngineAPINewPayloadData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalConsensusEngineAPIGetBlobsData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalConsensusEngineAPIGetBlobsData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalConsensusEngineAPIGetBlobsData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Slot != nil { + size, err := m.Slot.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Epoch != nil { + size, err := m.Epoch.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClientMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.AdditionalData.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if len(m.PresetName) > 0 { + i -= len(m.PresetName) + copy(dAtA[i:], m.PresetName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PresetName))) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0x82 + } + if m.ModuleName != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ModuleName)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xf8 + } + if len(m.Labels) > 0 { + for k := range m.Labels { + v := m.Labels[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x4a + } + } + if m.Ethereum != nil { + size, err := m.Ethereum.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.ClockDrift != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClockDrift)) + i-- + dAtA[i] = 0x30 + } + if len(m.Os) > 0 { + i -= len(m.Os) + copy(dAtA[i:], m.Os) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Os))) + i-- + dAtA[i] = 0x2a + } + if len(m.Implementation) > 0 { + i -= len(m.Implementation) + copy(dAtA[i:], m.Implementation) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Implementation))) + i-- + dAtA[i] = 0x22 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0x1a + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientMeta_EthV1EventsAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsAttestation != nil { + size, err := m.EthV1EventsAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsHead) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsHead) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsHead != nil { + size, err := m.EthV1EventsHead.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsBlock != nil { + size, err := m.EthV1EventsBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsVoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsVoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsVoluntaryExit != nil { + size, err := m.EthV1EventsVoluntaryExit.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsFinalizedCheckpoint) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsFinalizedCheckpoint) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsFinalizedCheckpoint != nil { + size, err := m.EthV1EventsFinalizedCheckpoint.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsChainReorg) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsChainReorg) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsChainReorg != nil { + size, err := m.EthV1EventsChainReorg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsContributionAndProof) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsContributionAndProof) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsContributionAndProof != nil { + size, err := m.EthV1EventsContributionAndProof.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_MempoolTransaction) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_MempoolTransaction) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MempoolTransaction != nil { + size, err := m.MempoolTransaction.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlock != nil { + size, err := m.EthV2BeaconBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1DebugForkChoice) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1DebugForkChoice) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1DebugForkChoice != nil { + size, err := m.EthV1DebugForkChoice.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1DebugForkChoiceReorg) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1DebugForkChoiceReorg) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1DebugForkChoiceReorg != nil { + size, err := m.EthV1DebugForkChoiceReorg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1BeaconCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1BeaconCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconCommittee != nil { + size, err := m.EthV1BeaconCommittee.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1ValidatorAttestationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1ValidatorAttestationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1ValidatorAttestationData != nil { + size, err := m.EthV1ValidatorAttestationData.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsAttestationV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsAttestationV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsAttestationV2 != nil { + size, err := m.EthV1EventsAttestationV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsHeadV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsHeadV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsHeadV2 != nil { + size, err := m.EthV1EventsHeadV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsBlockV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsBlockV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsBlockV2 != nil { + size, err := m.EthV1EventsBlockV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsVoluntaryExitV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsVoluntaryExitV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsVoluntaryExitV2 != nil { + size, err := m.EthV1EventsVoluntaryExitV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsFinalizedCheckpointV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsFinalizedCheckpointV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsFinalizedCheckpointV2 != nil { + size, err := m.EthV1EventsFinalizedCheckpointV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsChainReorgV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsChainReorgV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsChainReorgV2 != nil { + size, err := m.EthV1EventsChainReorgV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsContributionAndProofV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsContributionAndProofV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsContributionAndProofV2 != nil { + size, err := m.EthV1EventsContributionAndProofV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_MempoolTransactionV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_MempoolTransactionV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MempoolTransactionV2 != nil { + size, err := m.MempoolTransactionV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockV2 != nil { + size, err := m.EthV2BeaconBlockV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1DebugForkChoiceV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1DebugForkChoiceV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1DebugForkChoiceV2 != nil { + size, err := m.EthV1DebugForkChoiceV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1DebugForkChoiceReorgV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1DebugForkChoiceReorgV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1DebugForkChoiceReorgV2 != nil { + size, err := m.EthV1DebugForkChoiceReorgV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockAttesterSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockAttesterSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockAttesterSlashing != nil { + size, err := m.EthV2BeaconBlockAttesterSlashing.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockProposerSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockProposerSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockProposerSlashing != nil { + size, err := m.EthV2BeaconBlockProposerSlashing.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockVoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockVoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockVoluntaryExit != nil { + size, err := m.EthV2BeaconBlockVoluntaryExit.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockDeposit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockDeposit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockDeposit != nil { + size, err := m.EthV2BeaconBlockDeposit.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockBlsToExecutionChange) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockBlsToExecutionChange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockBlsToExecutionChange != nil { + size, err := m.EthV2BeaconBlockBlsToExecutionChange.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xba + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockExecutionTransaction) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockExecutionTransaction) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockExecutionTransaction != nil { + size, err := m.EthV2BeaconBlockExecutionTransaction.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockWithdrawal) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockWithdrawal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockWithdrawal != nil { + size, err := m.EthV2BeaconBlockWithdrawal.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsBlobSidecar != nil { + size, err := m.EthV1EventsBlobSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1BeaconBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1BeaconBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconBlobSidecar != nil { + size, err := m.EthV1BeaconBlobSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_BeaconP2PAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_BeaconP2PAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BeaconP2PAttestation != nil { + size, err := m.BeaconP2PAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1ProposerDuty) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1ProposerDuty) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1ProposerDuty != nil { + size, err := m.EthV1ProposerDuty.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockElaboratedAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockElaboratedAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockElaboratedAttestation != nil { + size, err := m.EthV2BeaconBlockElaboratedAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceAddPeer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceAddPeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceAddPeer != nil { + size, err := m.Libp2PTraceAddPeer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRemovePeer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRemovePeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRemovePeer != nil { + size, err := m.Libp2PTraceRemovePeer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRecvRpc) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRecvRpc) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRecvRpc != nil { + size, err := m.Libp2PTraceRecvRpc.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceSendRpc) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceSendRpc) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceSendRpc != nil { + size, err := m.Libp2PTraceSendRpc.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceJoin) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceJoin) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceJoin != nil { + size, err := m.Libp2PTraceJoin.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceConnected) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceConnected) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceConnected != nil { + size, err := m.Libp2PTraceConnected.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceDisconnected) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceDisconnected) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceDisconnected != nil { + size, err := m.Libp2PTraceDisconnected.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceHandleMetadata) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceHandleMetadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceHandleMetadata != nil { + size, err := m.Libp2PTraceHandleMetadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xba + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceHandleStatus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceHandleStatus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceHandleStatus != nil { + size, err := m.Libp2PTraceHandleStatus.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceGossipsubBeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceGossipsubBeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubBeaconBlock != nil { + size, err := m.Libp2PTraceGossipsubBeaconBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceGossipsubBeaconAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceGossipsubBeaconAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubBeaconAttestation != nil { + size, err := m.Libp2PTraceGossipsubBeaconAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceGossipsubBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceGossipsubBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubBlobSidecar != nil { + size, err := m.Libp2PTraceGossipsubBlobSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1Validators) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1Validators) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1Validators != nil { + size, err := m.EthV1Validators.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_MevRelayBidTraceBuilderBlockSubmission) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_MevRelayBidTraceBuilderBlockSubmission) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MevRelayBidTraceBuilderBlockSubmission != nil { + size, err := m.MevRelayBidTraceBuilderBlockSubmission.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_MevRelayPayloadDelivered) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_MevRelayPayloadDelivered) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MevRelayPayloadDelivered != nil { + size, err := m.MevRelayPayloadDelivered.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV3ValidatorBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV3ValidatorBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV3ValidatorBlock != nil { + size, err := m.EthV3ValidatorBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_MevRelayValidatorRegistration) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_MevRelayValidatorRegistration) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MevRelayValidatorRegistration != nil { + size, err := m.MevRelayValidatorRegistration.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsBlockGossip) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsBlockGossip) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsBlockGossip != nil { + size, err := m.EthV1EventsBlockGossip.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceDropRpc) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceDropRpc) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceDropRpc != nil { + size, err := m.Libp2PTraceDropRpc.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceLeave) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceLeave) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceLeave != nil { + size, err := m.Libp2PTraceLeave.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceGraft) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceGraft) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGraft != nil { + size, err := m.Libp2PTraceGraft.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTracePrune) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTracePrune) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTracePrune != nil { + size, err := m.Libp2PTracePrune.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xba + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceDuplicateMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceDuplicateMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceDuplicateMessage != nil { + size, err := m.Libp2PTraceDuplicateMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceDeliverMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceDeliverMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceDeliverMessage != nil { + size, err := m.Libp2PTraceDeliverMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTracePublishMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTracePublishMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTracePublishMessage != nil { + size, err := m.Libp2PTracePublishMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRejectMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRejectMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRejectMessage != nil { + size, err := m.Libp2PTraceRejectMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlIhave) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRpcMetaControlIhave) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlIhave != nil { + size, err := m.Libp2PTraceRpcMetaControlIhave.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlIwant) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRpcMetaControlIwant) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlIwant != nil { + size, err := m.Libp2PTraceRpcMetaControlIwant.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlIdontwant) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRpcMetaControlIdontwant) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlIdontwant != nil { + size, err := m.Libp2PTraceRpcMetaControlIdontwant.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlGraft) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRpcMetaControlGraft) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlGraft != nil { + size, err := m.Libp2PTraceRpcMetaControlGraft.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlPrune) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRpcMetaControlPrune) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlPrune != nil { + size, err := m.Libp2PTraceRpcMetaControlPrune.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRpcMetaSubscription) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRpcMetaSubscription) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaSubscription != nil { + size, err := m.Libp2PTraceRpcMetaSubscription.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRpcMetaMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRpcMetaMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaMessage != nil { + size, err := m.Libp2PTraceRpcMetaMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_NodeRecordConsensus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_NodeRecordConsensus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.NodeRecordConsensus != nil { + size, err := m.NodeRecordConsensus.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceGossipsubAggregateAndProof) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceGossipsubAggregateAndProof) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubAggregateAndProof != nil { + size, err := m.Libp2PTraceGossipsubAggregateAndProof.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1EventsDataColumnSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1EventsDataColumnSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsDataColumnSidecar != nil { + size, err := m.EthV1EventsDataColumnSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceGossipsubDataColumnSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceGossipsubDataColumnSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubDataColumnSidecar != nil { + size, err := m.Libp2PTraceGossipsubDataColumnSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceSyntheticHeartbeat) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceSyntheticHeartbeat) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceSyntheticHeartbeat != nil { + size, err := m.Libp2PTraceSyntheticHeartbeat.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xba + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceRpcDataColumnCustodyProbe) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceRpcDataColumnCustodyProbe) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcDataColumnCustodyProbe != nil { + size, err := m.Libp2PTraceRpcDataColumnCustodyProbe.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_ConsensusEngineApiNewPayload) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_ConsensusEngineApiNewPayload) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ConsensusEngineApiNewPayload != nil { + size, err := m.ConsensusEngineApiNewPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_ConsensusEngineApiGetBlobs) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_ConsensusEngineApiGetBlobs) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ConsensusEngineApiGetBlobs != nil { + size, err := m.ConsensusEngineApiGetBlobs.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1BeaconBlob) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1BeaconBlob) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconBlob != nil { + size, err := m.EthV1BeaconBlob.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV1BeaconSyncCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV1BeaconSyncCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconSyncCommittee != nil { + size, err := m.EthV1BeaconSyncCommittee.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_EthV2BeaconBlockSyncAggregate) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_EthV2BeaconBlockSyncAggregate) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockSyncAggregate != nil { + size, err := m.EthV2BeaconBlockSyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *ClientMeta_Libp2PTraceIdentify) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ClientMeta_Libp2PTraceIdentify) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceIdentify != nil { + size, err := m.Libp2PTraceIdentify.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *ServerMeta_Event) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_Event) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_Event) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ReceivedDateTime != nil { + size, err := (*timestamppb.Timestamp)(m.ReceivedDateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_Geo) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_Geo) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_Geo) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.AutonomousSystemOrganization) > 0 { + i -= len(m.AutonomousSystemOrganization) + copy(dAtA[i:], m.AutonomousSystemOrganization) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AutonomousSystemOrganization))) + i-- + dAtA[i] = 0x42 + } + if m.AutonomousSystemNumber != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.AutonomousSystemNumber)) + i-- + dAtA[i] = 0x38 + } + if m.Longitude != 0 { + i -= 8 + binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Longitude)))) + i-- + dAtA[i] = 0x31 + } + if m.Latitude != 0 { + i -= 8 + binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Latitude)))) + i-- + dAtA[i] = 0x29 + } + if len(m.ContinentCode) > 0 { + i -= len(m.ContinentCode) + copy(dAtA[i:], m.ContinentCode) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ContinentCode))) + i-- + dAtA[i] = 0x22 + } + if len(m.CountryCode) > 0 { + i -= len(m.CountryCode) + copy(dAtA[i:], m.CountryCode) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CountryCode))) + i-- + dAtA[i] = 0x1a + } + if len(m.Country) > 0 { + i -= len(m.Country) + copy(dAtA[i:], m.Country) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Country))) + i-- + dAtA[i] = 0x12 + } + if len(m.City) > 0 { + i -= len(m.City) + copy(dAtA[i:], m.City) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.City))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_Client) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_Client) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_Client) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.User) > 0 { + i -= len(m.User) + copy(dAtA[i:], m.User) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.User))) + i-- + dAtA[i] = 0x22 + } + if len(m.Group) > 0 { + i -= len(m.Group) + copy(dAtA[i:], m.Group) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Group))) + i-- + dAtA[i] = 0x1a + } + if m.Geo != nil { + size, err := m.Geo.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.IP) > 0 { + i -= len(m.IP) + copy(dAtA[i:], m.IP) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.IP))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_Peer) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_Peer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_Peer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Geo != nil { + size, err := m.Geo.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_AdditionalBeaconP2PAttestationData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_AdditionalBeaconP2PAttestationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_AdditionalBeaconP2PAttestationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Peer != nil { + size, err := m.Peer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_AdditionalLibp2PTraceConnectedData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_AdditionalLibp2PTraceConnectedData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_AdditionalLibp2PTraceConnectedData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Peer != nil { + size, err := m.Peer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_AdditionalLibp2PTraceDisconnectedData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_AdditionalLibp2PTraceDisconnectedData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_AdditionalLibp2PTraceDisconnectedData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Peer != nil { + size, err := m.Peer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Peer != nil { + size, err := m.Peer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_AdditionalLibp2PTraceIdentifyData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_AdditionalLibp2PTraceIdentifyData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_AdditionalLibp2PTraceIdentifyData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Peer != nil { + size, err := m.Peer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_AdditionalNodeRecordConsensusData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_AdditionalNodeRecordConsensusData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_AdditionalNodeRecordConsensusData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Geo != nil { + size, err := m.Geo.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_AdditionalNodeRecordExecutionData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta_AdditionalNodeRecordExecutionData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_AdditionalNodeRecordExecutionData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Geo != nil { + size, err := m.Geo.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ServerMeta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.AdditionalData.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if m.Client != nil { + size, err := m.Client.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Event != nil { + size, err := m.Event.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ServerMeta_BEACON_P2P_ATTESTATION) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_BEACON_P2P_ATTESTATION) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BEACON_P2P_ATTESTATION != nil { + size, err := m.BEACON_P2P_ATTESTATION.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *ServerMeta_LIBP2P_TRACE_CONNECTED) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_LIBP2P_TRACE_CONNECTED) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.LIBP2P_TRACE_CONNECTED != nil { + size, err := m.LIBP2P_TRACE_CONNECTED.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *ServerMeta_LIBP2P_TRACE_DISCONNECTED) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_LIBP2P_TRACE_DISCONNECTED) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.LIBP2P_TRACE_DISCONNECTED != nil { + size, err := m.LIBP2P_TRACE_DISCONNECTED.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *ServerMeta_NODE_RECORD_CONSENSUS) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_NODE_RECORD_CONSENSUS) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.NODE_RECORD_CONSENSUS != nil { + size, err := m.NODE_RECORD_CONSENSUS.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + return len(dAtA) - i, nil +} +func (m *ServerMeta_NODE_RECORD_EXECUTION) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_NODE_RECORD_EXECUTION) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.NODE_RECORD_EXECUTION != nil { + size, err := m.NODE_RECORD_EXECUTION.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + return len(dAtA) - i, nil +} +func (m *ServerMeta_LIBP2P_TRACE_SYNTHETIC_HEARTBEAT) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_LIBP2P_TRACE_SYNTHETIC_HEARTBEAT) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.LIBP2P_TRACE_SYNTHETIC_HEARTBEAT != nil { + size, err := m.LIBP2P_TRACE_SYNTHETIC_HEARTBEAT.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *ServerMeta_LIBP2P_TRACE_IDENTIFY) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ServerMeta_LIBP2P_TRACE_IDENTIFY) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.LIBP2P_TRACE_IDENTIFY != nil { + size, err := m.LIBP2P_TRACE_IDENTIFY.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *Meta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Meta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Meta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Server != nil { + size, err := m.Server.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Client != nil { + size, err := m.Client.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Event) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Event) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Event) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0x1a + } + if m.DateTime != nil { + size, err := (*timestamppb.Timestamp)(m.DateTime).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Name != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Name)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ExecutionBlockMetrics_StateReads) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionBlockMetrics_StateReads) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionBlockMetrics_StateReads) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.CodeBytes != nil { + size, err := (*wrapperspb.UInt64Value)(m.CodeBytes).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.Code != nil { + size, err := (*wrapperspb.UInt64Value)(m.Code).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.StorageSlots != nil { + size, err := (*wrapperspb.UInt64Value)(m.StorageSlots).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Accounts != nil { + size, err := (*wrapperspb.UInt64Value)(m.Accounts).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionBlockMetrics_StateWrites) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionBlockMetrics_StateWrites) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionBlockMetrics_StateWrites) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.CodeBytes != nil { + size, err := (*wrapperspb.UInt64Value)(m.CodeBytes).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Code != nil { + size, err := (*wrapperspb.UInt64Value)(m.Code).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.StorageSlotsDeleted != nil { + size, err := (*wrapperspb.UInt64Value)(m.StorageSlotsDeleted).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.StorageSlots != nil { + size, err := (*wrapperspb.UInt64Value)(m.StorageSlots).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.AccountsDeleted != nil { + size, err := (*wrapperspb.UInt64Value)(m.AccountsDeleted).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Accounts != nil { + size, err := (*wrapperspb.UInt64Value)(m.Accounts).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionBlockMetrics_CacheEntry) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionBlockMetrics_CacheEntry) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionBlockMetrics_CacheEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.HitRate != nil { + size, err := (*wrapperspb.DoubleValue)(m.HitRate).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Misses != nil { + size, err := (*wrapperspb.Int64Value)(m.Misses).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Hits != nil { + size, err := (*wrapperspb.Int64Value)(m.Hits).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionBlockMetrics_CodeCacheEntry) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionBlockMetrics_CodeCacheEntry) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionBlockMetrics_CodeCacheEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.MissBytes != nil { + size, err := (*wrapperspb.Int64Value)(m.MissBytes).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.HitBytes != nil { + size, err := (*wrapperspb.Int64Value)(m.HitBytes).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.HitRate != nil { + size, err := (*wrapperspb.DoubleValue)(m.HitRate).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Misses != nil { + size, err := (*wrapperspb.Int64Value)(m.Misses).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Hits != nil { + size, err := (*wrapperspb.Int64Value)(m.Hits).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExecutionBlockMetrics) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExecutionBlockMetrics) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExecutionBlockMetrics) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.CodeCache != nil { + size, err := m.CodeCache.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if m.StorageCache != nil { + size, err := m.StorageCache.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + if m.AccountCache != nil { + size, err := m.AccountCache.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + if m.StateWrites != nil { + size, err := m.StateWrites.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + if m.StateReads != nil { + size, err := m.StateReads.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.MgasPerSec != nil { + size, err := (*wrapperspb.DoubleValue)(m.MgasPerSec).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.TotalMs != nil { + size, err := (*wrapperspb.DoubleValue)(m.TotalMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.CommitMs != nil { + size, err := (*wrapperspb.DoubleValue)(m.CommitMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.StateHashMs != nil { + size, err := (*wrapperspb.DoubleValue)(m.StateHashMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if m.StateReadMs != nil { + size, err := (*wrapperspb.DoubleValue)(m.StateReadMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if m.ExecutionMs != nil { + size, err := (*wrapperspb.DoubleValue)(m.ExecutionMs).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.TxCount != nil { + size, err := (*wrapperspb.UInt32Value)(m.TxCount).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.GasUsed != nil { + size, err := (*wrapperspb.UInt64Value)(m.GasUsed).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x1a + } + if m.BlockNumber != nil { + size, err := (*wrapperspb.UInt64Value)(m.BlockNumber).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.Source) > 0 { + i -= len(m.Source) + copy(dAtA[i:], m.Source) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Source))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DecoratedEvent) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DecoratedEvent) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Data.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if m.Meta != nil { + size, err := m.Meta.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Event != nil { + size, err := m.Event.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DecoratedEvent_EthV1EventsAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsAttestation != nil { + size, err := m.EthV1EventsAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsBlock != nil { + size, err := m.EthV1EventsBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsChainReorg) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsChainReorg) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsChainReorg != nil { + size, err := m.EthV1EventsChainReorg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsFinalizedCheckpoint) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsFinalizedCheckpoint) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsFinalizedCheckpoint != nil { + size, err := m.EthV1EventsFinalizedCheckpoint.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsHead) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsHead) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsHead != nil { + size, err := m.EthV1EventsHead.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsVoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsVoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsVoluntaryExit != nil { + size, err := m.EthV1EventsVoluntaryExit.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsContributionAndProof) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsContributionAndProof) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsContributionAndProof != nil { + size, err := m.EthV1EventsContributionAndProof.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_MempoolTransaction) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_MempoolTransaction) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + i -= len(m.MempoolTransaction) + copy(dAtA[i:], m.MempoolTransaction) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MempoolTransaction))) + i-- + dAtA[i] = 0x52 + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlock != nil { + size, err := m.EthV2BeaconBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1ForkChoice) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1ForkChoice) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1ForkChoice != nil { + size, err := m.EthV1ForkChoice.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1ForkChoiceReorg) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1ForkChoiceReorg) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1ForkChoiceReorg != nil { + size, err := m.EthV1ForkChoiceReorg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x6a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1BeaconCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1BeaconCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconCommittee != nil { + size, err := m.EthV1BeaconCommittee.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1ValidatorAttestationData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1ValidatorAttestationData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1ValidatorAttestationData != nil { + size, err := m.EthV1ValidatorAttestationData.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsAttestationV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsAttestationV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsAttestationV2 != nil { + size, err := m.EthV1EventsAttestationV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsBlockV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsBlockV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsBlockV2 != nil { + size, err := m.EthV1EventsBlockV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsChainReorgV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsChainReorgV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsChainReorgV2 != nil { + size, err := m.EthV1EventsChainReorgV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsFinalizedCheckpointV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsFinalizedCheckpointV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsFinalizedCheckpointV2 != nil { + size, err := m.EthV1EventsFinalizedCheckpointV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsHeadV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsHeadV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsHeadV2 != nil { + size, err := m.EthV1EventsHeadV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsVoluntaryExitV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsVoluntaryExitV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsVoluntaryExitV2 != nil { + size, err := m.EthV1EventsVoluntaryExitV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsContributionAndProofV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsContributionAndProofV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsContributionAndProofV2 != nil { + size, err := m.EthV1EventsContributionAndProofV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_MempoolTransactionV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_MempoolTransactionV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + i -= len(m.MempoolTransactionV2) + copy(dAtA[i:], m.MempoolTransactionV2) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MempoolTransactionV2))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xba + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockV2 != nil { + size, err := m.EthV2BeaconBlockV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1ForkChoiceV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1ForkChoiceV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1ForkChoiceV2 != nil { + size, err := m.EthV1ForkChoiceV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1ForkChoiceReorgV2) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1ForkChoiceReorgV2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1ForkChoiceReorgV2 != nil { + size, err := m.EthV1ForkChoiceReorgV2.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockAttesterSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockAttesterSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockAttesterSlashing != nil { + size, err := m.EthV2BeaconBlockAttesterSlashing.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockProposerSlashing) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockProposerSlashing) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockProposerSlashing != nil { + size, err := m.EthV2BeaconBlockProposerSlashing.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockVoluntaryExit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockVoluntaryExit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockVoluntaryExit != nil { + size, err := m.EthV2BeaconBlockVoluntaryExit.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockDeposit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockDeposit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockDeposit != nil { + size, err := m.EthV2BeaconBlockDeposit.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockBlsToExecutionChange) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockBlsToExecutionChange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockBlsToExecutionChange != nil { + size, err := m.EthV2BeaconBlockBlsToExecutionChange.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockExecutionTransaction) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockExecutionTransaction) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockExecutionTransaction != nil { + size, err := m.EthV2BeaconBlockExecutionTransaction.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockWithdrawal) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockWithdrawal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockWithdrawal != nil { + size, err := m.EthV2BeaconBlockWithdrawal.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsBlobSidecar != nil { + size, err := m.EthV1EventsBlobSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1BeaconBlockBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1BeaconBlockBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconBlockBlobSidecar != nil { + size, err := m.EthV1BeaconBlockBlobSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_BeaconP2PAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_BeaconP2PAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BeaconP2PAttestation != nil { + size, err := m.BeaconP2PAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1ProposerDuty) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1ProposerDuty) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1ProposerDuty != nil { + size, err := m.EthV1ProposerDuty.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockElaboratedAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockElaboratedAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockElaboratedAttestation != nil { + size, err := m.EthV2BeaconBlockElaboratedAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xba + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceAddPeer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceAddPeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceAddPeer != nil { + size, err := m.Libp2PTraceAddPeer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRemovePeer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRemovePeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRemovePeer != nil { + size, err := m.Libp2PTraceRemovePeer.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRecvRpc) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRecvRpc) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRecvRpc != nil { + size, err := m.Libp2PTraceRecvRpc.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceSendRpc) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceSendRpc) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceSendRpc != nil { + size, err := m.Libp2PTraceSendRpc.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceJoin) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceJoin) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceJoin != nil { + size, err := m.Libp2PTraceJoin.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceConnected) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceConnected) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceConnected != nil { + size, err := m.Libp2PTraceConnected.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceDisconnected) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceDisconnected) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceDisconnected != nil { + size, err := m.Libp2PTraceDisconnected.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceHandleMetadata) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceHandleMetadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceHandleMetadata != nil { + size, err := m.Libp2PTraceHandleMetadata.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceHandleStatus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceHandleStatus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceHandleStatus != nil { + size, err := m.Libp2PTraceHandleStatus.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceGossipsubBeaconBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceGossipsubBeaconBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubBeaconBlock != nil { + size, err := m.Libp2PTraceGossipsubBeaconBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceGossipsubBeaconAttestation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceGossipsubBeaconAttestation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubBeaconAttestation != nil { + size, err := m.Libp2PTraceGossipsubBeaconAttestation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceGossipsubBlobSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceGossipsubBlobSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubBlobSidecar != nil { + size, err := m.Libp2PTraceGossipsubBlobSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1Validators) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1Validators) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1Validators != nil { + size, err := m.EthV1Validators.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_MevRelayBidTraceBuilderBlockSubmission) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_MevRelayBidTraceBuilderBlockSubmission) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MevRelayBidTraceBuilderBlockSubmission != nil { + size, err := m.MevRelayBidTraceBuilderBlockSubmission.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_MevRelayPayloadDelivered) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_MevRelayPayloadDelivered) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MevRelayPayloadDelivered != nil { + size, err := m.MevRelayPayloadDelivered.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV3ValidatorBlock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV3ValidatorBlock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV3ValidatorBlock != nil { + size, err := m.EthV3ValidatorBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xba + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_MevRelayValidatorRegistration) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_MevRelayValidatorRegistration) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MevRelayValidatorRegistration != nil { + size, err := m.MevRelayValidatorRegistration.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsBlockGossip) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsBlockGossip) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsBlockGossip != nil { + size, err := m.EthV1EventsBlockGossip.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceDropRpc) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceDropRpc) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceDropRpc != nil { + size, err := m.Libp2PTraceDropRpc.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceLeave) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceLeave) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceLeave != nil { + size, err := m.Libp2PTraceLeave.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceGraft) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceGraft) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGraft != nil { + size, err := m.Libp2PTraceGraft.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTracePrune) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTracePrune) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTracePrune != nil { + size, err := m.Libp2PTracePrune.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceDuplicateMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceDuplicateMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceDuplicateMessage != nil { + size, err := m.Libp2PTraceDuplicateMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceDeliverMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceDeliverMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceDeliverMessage != nil { + size, err := m.Libp2PTraceDeliverMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTracePublishMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTracePublishMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTracePublishMessage != nil { + size, err := m.Libp2PTracePublishMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRejectMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRejectMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRejectMessage != nil { + size, err := m.Libp2PTraceRejectMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIhave) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIhave) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlIhave != nil { + size, err := m.Libp2PTraceRpcMetaControlIhave.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIwant) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIwant) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlIwant != nil { + size, err := m.Libp2PTraceRpcMetaControlIwant.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIdontwant) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIdontwant) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlIdontwant != nil { + size, err := m.Libp2PTraceRpcMetaControlIdontwant.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlGraft) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlGraft) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlGraft != nil { + size, err := m.Libp2PTraceRpcMetaControlGraft.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlPrune) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlPrune) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaControlPrune != nil { + size, err := m.Libp2PTraceRpcMetaControlPrune.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaSubscription) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRpcMetaSubscription) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaSubscription != nil { + size, err := m.Libp2PTraceRpcMetaSubscription.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xba + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaMessage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRpcMetaMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcMetaMessage != nil { + size, err := m.Libp2PTraceRpcMetaMessage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_NodeRecordConsensus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_NodeRecordConsensus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.NodeRecordConsensus != nil { + size, err := m.NodeRecordConsensus.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_NodeRecordExecution) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_NodeRecordExecution) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.NodeRecordExecution != nil { + size, err := m.NodeRecordExecution.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceGossipsubAggregateAndProof) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceGossipsubAggregateAndProof) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubAggregateAndProof != nil { + size, err := m.Libp2PTraceGossipsubAggregateAndProof.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1EventsDataColumnSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1EventsDataColumnSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1EventsDataColumnSidecar != nil { + size, err := m.EthV1EventsDataColumnSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceGossipsubDataColumnSidecar) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceGossipsubDataColumnSidecar) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceGossipsubDataColumnSidecar != nil { + size, err := m.Libp2PTraceGossipsubDataColumnSidecar.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceSyntheticHeartbeat) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceSyntheticHeartbeat) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceSyntheticHeartbeat != nil { + size, err := m.Libp2PTraceSyntheticHeartbeat.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceIdentify) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceIdentify) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceIdentify != nil { + size, err := m.Libp2PTraceIdentify.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_Libp2PTraceRpcDataColumnCustodyProbe) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_Libp2PTraceRpcDataColumnCustodyProbe) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Libp2PTraceRpcDataColumnCustodyProbe != nil { + size, err := m.Libp2PTraceRpcDataColumnCustodyProbe.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_ExecutionStateSize) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_ExecutionStateSize) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ExecutionStateSize != nil { + size, err := m.ExecutionStateSize.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xca + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_ConsensusEngineApiNewPayload) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_ConsensusEngineApiNewPayload) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ConsensusEngineApiNewPayload != nil { + size, err := m.ConsensusEngineApiNewPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xd2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_ConsensusEngineApiGetBlobs) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_ConsensusEngineApiGetBlobs) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ConsensusEngineApiGetBlobs != nil { + size, err := m.ConsensusEngineApiGetBlobs.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xda + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_ExecutionEngineNewPayload) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_ExecutionEngineNewPayload) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ExecutionEngineNewPayload != nil { + size, err := m.ExecutionEngineNewPayload.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_ExecutionEngineGetBlobs) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_ExecutionEngineGetBlobs) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ExecutionEngineGetBlobs != nil { + size, err := m.ExecutionEngineGetBlobs.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1BeaconBlob) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1BeaconBlob) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconBlob != nil { + size, err := m.EthV1BeaconBlob.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV1BeaconSyncCommittee) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV1BeaconSyncCommittee) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV1BeaconSyncCommittee != nil { + size, err := m.EthV1BeaconSyncCommittee.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xfa + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_EthV2BeaconBlockSyncAggregate) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_EthV2BeaconBlockSyncAggregate) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.EthV2BeaconBlockSyncAggregate != nil { + size, err := m.EthV2BeaconBlockSyncAggregate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xd + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *DecoratedEvent_ExecutionBlockMetrics) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DecoratedEvent_ExecutionBlockMetrics) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ExecutionBlockMetrics != nil { + size, err := m.ExecutionBlockMetrics.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xd + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} + +var vtprotoPool_CreateEventsRequest = sync.Pool{ + New: func() interface{} { + return &CreateEventsRequest{} + }, +} + +func (m *CreateEventsRequest) ResetVT() { + if m != nil { + for _, mm := range m.Events { + mm.ResetVT() + } + f0 := m.Events[:0] + m.Reset() + m.Events = f0 + } +} +func (m *CreateEventsRequest) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateEventsRequest.Put(m) + } +} +func CreateEventsRequestFromVTPool() *CreateEventsRequest { + return vtprotoPool_CreateEventsRequest.Get().(*CreateEventsRequest) +} + +var vtprotoPool_CreateEventsResponse = sync.Pool{ + New: func() interface{} { + return &CreateEventsResponse{} + }, +} + +func (m *CreateEventsResponse) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *CreateEventsResponse) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_CreateEventsResponse.Put(m) + } +} +func CreateEventsResponseFromVTPool() *CreateEventsResponse { + return vtprotoPool_CreateEventsResponse.Get().(*CreateEventsResponse) +} + +var vtprotoPool_Epoch = sync.Pool{ + New: func() interface{} { + return &Epoch{} + }, +} + +func (m *Epoch) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Epoch) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Epoch.Put(m) + } +} +func EpochFromVTPool() *Epoch { + return vtprotoPool_Epoch.Get().(*Epoch) +} + +var vtprotoPool_EpochV2 = sync.Pool{ + New: func() interface{} { + return &EpochV2{} + }, +} + +func (m *EpochV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *EpochV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_EpochV2.Put(m) + } +} +func EpochV2FromVTPool() *EpochV2 { + return vtprotoPool_EpochV2.Get().(*EpochV2) +} + +var vtprotoPool_Slot = sync.Pool{ + New: func() interface{} { + return &Slot{} + }, +} + +func (m *Slot) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Slot) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Slot.Put(m) + } +} +func SlotFromVTPool() *Slot { + return vtprotoPool_Slot.Get().(*Slot) +} + +var vtprotoPool_SlotV2 = sync.Pool{ + New: func() interface{} { + return &SlotV2{} + }, +} + +func (m *SlotV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *SlotV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SlotV2.Put(m) + } +} +func SlotV2FromVTPool() *SlotV2 { + return vtprotoPool_SlotV2.Get().(*SlotV2) +} + +var vtprotoPool_ForkID = sync.Pool{ + New: func() interface{} { + return &ForkID{} + }, +} + +func (m *ForkID) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ForkID) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ForkID.Put(m) + } +} +func ForkIDFromVTPool() *ForkID { + return vtprotoPool_ForkID.Get().(*ForkID) +} + +var vtprotoPool_Propagation = sync.Pool{ + New: func() interface{} { + return &Propagation{} + }, +} + +func (m *Propagation) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Propagation) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Propagation.Put(m) + } +} +func PropagationFromVTPool() *Propagation { + return vtprotoPool_Propagation.Get().(*Propagation) +} + +var vtprotoPool_PropagationV2 = sync.Pool{ + New: func() interface{} { + return &PropagationV2{} + }, +} + +func (m *PropagationV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *PropagationV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_PropagationV2.Put(m) + } +} +func PropagationV2FromVTPool() *PropagationV2 { + return vtprotoPool_PropagationV2.Get().(*PropagationV2) +} + +var vtprotoPool_AttestingValidator = sync.Pool{ + New: func() interface{} { + return &AttestingValidator{} + }, +} + +func (m *AttestingValidator) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *AttestingValidator) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AttestingValidator.Put(m) + } +} +func AttestingValidatorFromVTPool() *AttestingValidator { + return vtprotoPool_AttestingValidator.Get().(*AttestingValidator) +} + +var vtprotoPool_AttestingValidatorV2 = sync.Pool{ + New: func() interface{} { + return &AttestingValidatorV2{} + }, +} + +func (m *AttestingValidatorV2) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *AttestingValidatorV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_AttestingValidatorV2.Put(m) + } +} +func AttestingValidatorV2FromVTPool() *AttestingValidatorV2 { + return vtprotoPool_AttestingValidatorV2.Get().(*AttestingValidatorV2) +} + +var vtprotoPool_DebugForkChoiceReorg = sync.Pool{ + New: func() interface{} { + return &DebugForkChoiceReorg{} + }, +} + +func (m *DebugForkChoiceReorg) ResetVT() { + if m != nil { + m.Before.ReturnToVTPool() + m.After.ReturnToVTPool() + m.Event.ReturnToVTPool() + m.Reset() + } +} +func (m *DebugForkChoiceReorg) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DebugForkChoiceReorg.Put(m) + } +} +func DebugForkChoiceReorgFromVTPool() *DebugForkChoiceReorg { + return vtprotoPool_DebugForkChoiceReorg.Get().(*DebugForkChoiceReorg) +} + +var vtprotoPool_DebugForkChoiceReorgV2 = sync.Pool{ + New: func() interface{} { + return &DebugForkChoiceReorgV2{} + }, +} + +func (m *DebugForkChoiceReorgV2) ResetVT() { + if m != nil { + m.Before.ReturnToVTPool() + m.After.ReturnToVTPool() + m.Event.ReturnToVTPool() + m.Reset() + } +} +func (m *DebugForkChoiceReorgV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DebugForkChoiceReorgV2.Put(m) + } +} +func DebugForkChoiceReorgV2FromVTPool() *DebugForkChoiceReorgV2 { + return vtprotoPool_DebugForkChoiceReorgV2.Get().(*DebugForkChoiceReorgV2) +} + +var vtprotoPool_Validators = sync.Pool{ + New: func() interface{} { + return &Validators{} + }, +} + +func (m *Validators) ResetVT() { + if m != nil { + for _, mm := range m.Validators { + mm.ResetVT() + } + f0 := m.Validators[:0] + m.Reset() + m.Validators = f0 + } +} +func (m *Validators) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Validators.Put(m) + } +} +func ValidatorsFromVTPool() *Validators { + return vtprotoPool_Validators.Get().(*Validators) +} + +var vtprotoPool_SyncCommitteeData = sync.Pool{ + New: func() interface{} { + return &SyncCommitteeData{} + }, +} + +func (m *SyncCommitteeData) ResetVT() { + if m != nil { + m.SyncCommittee.ReturnToVTPool() + m.Reset() + } +} +func (m *SyncCommitteeData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SyncCommitteeData.Put(m) + } +} +func SyncCommitteeDataFromVTPool() *SyncCommitteeData { + return vtprotoPool_SyncCommitteeData.Get().(*SyncCommitteeData) +} + +var vtprotoPool_SyncAggregateData = sync.Pool{ + New: func() interface{} { + return &SyncAggregateData{} + }, +} + +func (m *SyncAggregateData) ResetVT() { + if m != nil { + for _, mm := range m.ValidatorsParticipated { + mm.Reset() + } + f0 := m.ValidatorsParticipated[:0] + for _, mm := range m.ValidatorsMissed { + mm.Reset() + } + f1 := m.ValidatorsMissed[:0] + m.Reset() + m.ValidatorsParticipated = f0 + m.ValidatorsMissed = f1 + } +} +func (m *SyncAggregateData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_SyncAggregateData.Put(m) + } +} +func SyncAggregateDataFromVTPool() *SyncAggregateData { + return vtprotoPool_SyncAggregateData.Get().(*SyncAggregateData) +} + +var vtprotoPool_BlockIdentifier = sync.Pool{ + New: func() interface{} { + return &BlockIdentifier{} + }, +} + +func (m *BlockIdentifier) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *BlockIdentifier) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_BlockIdentifier.Put(m) + } +} +func BlockIdentifierFromVTPool() *BlockIdentifier { + return vtprotoPool_BlockIdentifier.Get().(*BlockIdentifier) +} + +var vtprotoPool_ExecutionStateSize = sync.Pool{ + New: func() interface{} { + return &ExecutionStateSize{} + }, +} + +func (m *ExecutionStateSize) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionStateSize) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionStateSize.Put(m) + } +} +func ExecutionStateSizeFromVTPool() *ExecutionStateSize { + return vtprotoPool_ExecutionStateSize.Get().(*ExecutionStateSize) +} + +var vtprotoPool_ConsensusEngineAPINewPayload = sync.Pool{ + New: func() interface{} { + return &ConsensusEngineAPINewPayload{} + }, +} + +func (m *ConsensusEngineAPINewPayload) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ConsensusEngineAPINewPayload) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ConsensusEngineAPINewPayload.Put(m) + } +} +func ConsensusEngineAPINewPayloadFromVTPool() *ConsensusEngineAPINewPayload { + return vtprotoPool_ConsensusEngineAPINewPayload.Get().(*ConsensusEngineAPINewPayload) +} + +var vtprotoPool_ConsensusEngineAPIGetBlobs = sync.Pool{ + New: func() interface{} { + return &ConsensusEngineAPIGetBlobs{} + }, +} + +func (m *ConsensusEngineAPIGetBlobs) ResetVT() { + if m != nil { + f0 := m.VersionedHashes[:0] + m.Reset() + m.VersionedHashes = f0 + } +} +func (m *ConsensusEngineAPIGetBlobs) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ConsensusEngineAPIGetBlobs.Put(m) + } +} +func ConsensusEngineAPIGetBlobsFromVTPool() *ConsensusEngineAPIGetBlobs { + return vtprotoPool_ConsensusEngineAPIGetBlobs.Get().(*ConsensusEngineAPIGetBlobs) +} + +var vtprotoPool_ExecutionEngineNewPayload = sync.Pool{ + New: func() interface{} { + return &ExecutionEngineNewPayload{} + }, +} + +func (m *ExecutionEngineNewPayload) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionEngineNewPayload) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionEngineNewPayload.Put(m) + } +} +func ExecutionEngineNewPayloadFromVTPool() *ExecutionEngineNewPayload { + return vtprotoPool_ExecutionEngineNewPayload.Get().(*ExecutionEngineNewPayload) +} + +var vtprotoPool_ExecutionEngineGetBlobs = sync.Pool{ + New: func() interface{} { + return &ExecutionEngineGetBlobs{} + }, +} + +func (m *ExecutionEngineGetBlobs) ResetVT() { + if m != nil { + f0 := m.VersionedHashes[:0] + for _, mm := range m.ReturnedBlobIndexes { + mm.Reset() + } + f1 := m.ReturnedBlobIndexes[:0] + m.Reset() + m.VersionedHashes = f0 + m.ReturnedBlobIndexes = f1 + } +} +func (m *ExecutionEngineGetBlobs) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionEngineGetBlobs.Put(m) + } +} +func ExecutionEngineGetBlobsFromVTPool() *ExecutionEngineGetBlobs { + return vtprotoPool_ExecutionEngineGetBlobs.Get().(*ExecutionEngineGetBlobs) +} + +var vtprotoPool_ClientMeta_Ethereum_Network = sync.Pool{ + New: func() interface{} { + return &ClientMeta_Ethereum_Network{} + }, +} + +func (m *ClientMeta_Ethereum_Network) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ClientMeta_Ethereum_Network) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_Ethereum_Network.Put(m) + } +} +func ClientMeta_Ethereum_NetworkFromVTPool() *ClientMeta_Ethereum_Network { + return vtprotoPool_ClientMeta_Ethereum_Network.Get().(*ClientMeta_Ethereum_Network) +} + +var vtprotoPool_ClientMeta_Ethereum_Execution = sync.Pool{ + New: func() interface{} { + return &ClientMeta_Ethereum_Execution{} + }, +} + +func (m *ClientMeta_Ethereum_Execution) ResetVT() { + if m != nil { + m.ForkId.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_Ethereum_Execution) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_Ethereum_Execution.Put(m) + } +} +func ClientMeta_Ethereum_ExecutionFromVTPool() *ClientMeta_Ethereum_Execution { + return vtprotoPool_ClientMeta_Ethereum_Execution.Get().(*ClientMeta_Ethereum_Execution) +} + +var vtprotoPool_ClientMeta_Ethereum_Consensus = sync.Pool{ + New: func() interface{} { + return &ClientMeta_Ethereum_Consensus{} + }, +} + +func (m *ClientMeta_Ethereum_Consensus) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ClientMeta_Ethereum_Consensus) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_Ethereum_Consensus.Put(m) + } +} +func ClientMeta_Ethereum_ConsensusFromVTPool() *ClientMeta_Ethereum_Consensus { + return vtprotoPool_ClientMeta_Ethereum_Consensus.Get().(*ClientMeta_Ethereum_Consensus) +} + +var vtprotoPool_ClientMeta_Ethereum = sync.Pool{ + New: func() interface{} { + return &ClientMeta_Ethereum{} + }, +} + +func (m *ClientMeta_Ethereum) ResetVT() { + if m != nil { + m.Network.ReturnToVTPool() + m.Execution.ReturnToVTPool() + m.Consensus.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_Ethereum) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_Ethereum.Put(m) + } +} +func ClientMeta_EthereumFromVTPool() *ClientMeta_Ethereum { + return vtprotoPool_ClientMeta_Ethereum.Get().(*ClientMeta_Ethereum) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1AttestationSourceData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1AttestationSourceData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1AttestationSourceData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1AttestationSourceData.Put(m) + } +} +func ClientMeta_AdditionalEthV1AttestationSourceDataFromVTPool() *ClientMeta_AdditionalEthV1AttestationSourceData { + return vtprotoPool_ClientMeta_AdditionalEthV1AttestationSourceData.Get().(*ClientMeta_AdditionalEthV1AttestationSourceData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1AttestationSourceV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1AttestationSourceV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1AttestationSourceV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1AttestationSourceV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1AttestationSourceV2DataFromVTPool() *ClientMeta_AdditionalEthV1AttestationSourceV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1AttestationSourceV2Data.Get().(*ClientMeta_AdditionalEthV1AttestationSourceV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1AttestationTargetData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1AttestationTargetData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1AttestationTargetData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1AttestationTargetData.Put(m) + } +} +func ClientMeta_AdditionalEthV1AttestationTargetDataFromVTPool() *ClientMeta_AdditionalEthV1AttestationTargetData { + return vtprotoPool_ClientMeta_AdditionalEthV1AttestationTargetData.Get().(*ClientMeta_AdditionalEthV1AttestationTargetData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1AttestationTargetV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1AttestationTargetV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1AttestationTargetV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1AttestationTargetV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1AttestationTargetV2DataFromVTPool() *ClientMeta_AdditionalEthV1AttestationTargetV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1AttestationTargetV2Data.Get().(*ClientMeta_AdditionalEthV1AttestationTargetV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsAttestationData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsAttestationData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationData) ResetVT() { + if m != nil { + m.Source.ReturnToVTPool() + m.Target.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.AttestingValidator.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsAttestationData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsAttestationData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsAttestationDataFromVTPool() *ClientMeta_AdditionalEthV1EventsAttestationData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsAttestationData.Get().(*ClientMeta_AdditionalEthV1EventsAttestationData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsAttestationV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsAttestationV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationV2Data) ResetVT() { + if m != nil { + m.Source.ReturnToVTPool() + m.Target.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.AttestingValidator.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsAttestationV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsAttestationV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsAttestationV2DataFromVTPool() *ClientMeta_AdditionalEthV1EventsAttestationV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsAttestationV2Data.Get().(*ClientMeta_AdditionalEthV1EventsAttestationV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsHeadData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsHeadData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsHeadData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsHeadData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsHeadDataFromVTPool() *ClientMeta_AdditionalEthV1EventsHeadData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsHeadData.Get().(*ClientMeta_AdditionalEthV1EventsHeadData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsHeadV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsHeadV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsHeadV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsHeadV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsHeadV2DataFromVTPool() *ClientMeta_AdditionalEthV1EventsHeadV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsHeadV2Data.Get().(*ClientMeta_AdditionalEthV1EventsHeadV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsBlockData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsBlockData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsBlockDataFromVTPool() *ClientMeta_AdditionalEthV1EventsBlockData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockData.Get().(*ClientMeta_AdditionalEthV1EventsBlockData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsBlockV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsBlockV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsBlockV2DataFromVTPool() *ClientMeta_AdditionalEthV1EventsBlockV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockV2Data.Get().(*ClientMeta_AdditionalEthV1EventsBlockV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockGossipData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsBlockGossipData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockGossipData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsBlockGossipData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockGossipData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsBlockGossipDataFromVTPool() *ClientMeta_AdditionalEthV1EventsBlockGossipData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsBlockGossipData.Get().(*ClientMeta_AdditionalEthV1EventsBlockGossipData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsVoluntaryExitData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsVoluntaryExitData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsVoluntaryExitData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsVoluntaryExitDataFromVTPool() *ClientMeta_AdditionalEthV1EventsVoluntaryExitData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsVoluntaryExitData.Get().(*ClientMeta_AdditionalEthV1EventsVoluntaryExitData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsVoluntaryExitV2DataFromVTPool() *ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data.Get().(*ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsFinalizedCheckpointDataFromVTPool() *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData.Get().(*ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2DataFromVTPool() *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data.Get().(*ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsChainReorgData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsChainReorgData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsChainReorgData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsChainReorgData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsChainReorgDataFromVTPool() *ClientMeta_AdditionalEthV1EventsChainReorgData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsChainReorgData.Get().(*ClientMeta_AdditionalEthV1EventsChainReorgData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsChainReorgV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsChainReorgV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsChainReorgV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsChainReorgV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsChainReorgV2DataFromVTPool() *ClientMeta_AdditionalEthV1EventsChainReorgV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsChainReorgV2Data.Get().(*ClientMeta_AdditionalEthV1EventsChainReorgV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsContributionAndProofContributionDataFromVTPool() *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData.Get().(*ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2DataFromVTPool() *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data.Get().(*ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsContributionAndProofData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofData) ResetVT() { + if m != nil { + m.Contribution.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsContributionAndProofDataFromVTPool() *ClientMeta_AdditionalEthV1EventsContributionAndProofData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofData.Get().(*ClientMeta_AdditionalEthV1EventsContributionAndProofData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data) ResetVT() { + if m != nil { + m.Contribution.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsContributionAndProofV2DataFromVTPool() *ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data.Get().(*ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data) +} + +var vtprotoPool_ClientMeta_ForkChoiceSnapshot = sync.Pool{ + New: func() interface{} { + return &ClientMeta_ForkChoiceSnapshot{} + }, +} + +func (m *ClientMeta_ForkChoiceSnapshot) ResetVT() { + if m != nil { + m.RequestEpoch.ReturnToVTPool() + m.RequestSlot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_ForkChoiceSnapshot) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_ForkChoiceSnapshot.Put(m) + } +} +func ClientMeta_ForkChoiceSnapshotFromVTPool() *ClientMeta_ForkChoiceSnapshot { + return vtprotoPool_ClientMeta_ForkChoiceSnapshot.Get().(*ClientMeta_ForkChoiceSnapshot) +} + +var vtprotoPool_ClientMeta_ForkChoiceSnapshotV2 = sync.Pool{ + New: func() interface{} { + return &ClientMeta_ForkChoiceSnapshotV2{} + }, +} + +func (m *ClientMeta_ForkChoiceSnapshotV2) ResetVT() { + if m != nil { + m.RequestEpoch.ReturnToVTPool() + m.RequestSlot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_ForkChoiceSnapshotV2) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_ForkChoiceSnapshotV2.Put(m) + } +} +func ClientMeta_ForkChoiceSnapshotV2FromVTPool() *ClientMeta_ForkChoiceSnapshotV2 { + return vtprotoPool_ClientMeta_ForkChoiceSnapshotV2.Get().(*ClientMeta_ForkChoiceSnapshotV2) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1DebugForkChoiceData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceData) ResetVT() { + if m != nil { + m.Snapshot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceData.Put(m) + } +} +func ClientMeta_AdditionalEthV1DebugForkChoiceDataFromVTPool() *ClientMeta_AdditionalEthV1DebugForkChoiceData { + return vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceData.Get().(*ClientMeta_AdditionalEthV1DebugForkChoiceData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1DebugForkChoiceV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceV2Data) ResetVT() { + if m != nil { + m.Snapshot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1DebugForkChoiceV2DataFromVTPool() *ClientMeta_AdditionalEthV1DebugForkChoiceV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceV2Data.Get().(*ClientMeta_AdditionalEthV1DebugForkChoiceV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData) ResetVT() { + if m != nil { + m.Before.ReturnToVTPool() + m.After.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData.Put(m) + } +} +func ClientMeta_AdditionalEthV1DebugForkChoiceReOrgDataFromVTPool() *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData { + return vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData.Get().(*ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data) ResetVT() { + if m != nil { + m.Before.ReturnToVTPool() + m.After.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2DataFromVTPool() *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data.Get().(*ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1BeaconCommitteeData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1BeaconCommitteeData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1BeaconCommitteeData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1BeaconCommitteeData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1BeaconCommitteeData.Put(m) + } +} +func ClientMeta_AdditionalEthV1BeaconCommitteeDataFromVTPool() *ClientMeta_AdditionalEthV1BeaconCommitteeData { + return vtprotoPool_ClientMeta_AdditionalEthV1BeaconCommitteeData.Get().(*ClientMeta_AdditionalEthV1BeaconCommitteeData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1BeaconSyncCommitteeData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1BeaconSyncCommitteeData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1BeaconSyncCommitteeData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1BeaconSyncCommitteeData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1BeaconSyncCommitteeData.Put(m) + } +} +func ClientMeta_AdditionalEthV1BeaconSyncCommitteeDataFromVTPool() *ClientMeta_AdditionalEthV1BeaconSyncCommitteeData { + return vtprotoPool_ClientMeta_AdditionalEthV1BeaconSyncCommitteeData.Get().(*ClientMeta_AdditionalEthV1BeaconSyncCommitteeData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData) +} + +var vtprotoPool_ClientMeta_AdditionalMempoolTransactionData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalMempoolTransactionData{} + }, +} + +func (m *ClientMeta_AdditionalMempoolTransactionData) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ClientMeta_AdditionalMempoolTransactionData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalMempoolTransactionData.Put(m) + } +} +func ClientMeta_AdditionalMempoolTransactionDataFromVTPool() *ClientMeta_AdditionalMempoolTransactionData { + return vtprotoPool_ClientMeta_AdditionalMempoolTransactionData.Get().(*ClientMeta_AdditionalMempoolTransactionData) +} + +var vtprotoPool_ClientMeta_AdditionalMempoolTransactionV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalMempoolTransactionV2Data{} + }, +} + +func (m *ClientMeta_AdditionalMempoolTransactionV2Data) ResetVT() { + if m != nil { + f0 := m.BlobHashes[:0] + m.Reset() + m.BlobHashes = f0 + } +} +func (m *ClientMeta_AdditionalMempoolTransactionV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalMempoolTransactionV2Data.Put(m) + } +} +func ClientMeta_AdditionalMempoolTransactionV2DataFromVTPool() *ClientMeta_AdditionalMempoolTransactionV2Data { + return vtprotoPool_ClientMeta_AdditionalMempoolTransactionV2Data.Get().(*ClientMeta_AdditionalMempoolTransactionV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockV2Data = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockV2Data{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockV2Data) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockV2Data) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockV2Data.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockV2DataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockV2Data { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockV2Data.Get().(*ClientMeta_AdditionalEthV2BeaconBlockV2Data) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockDepositData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockDepositData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockDepositData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockDepositData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockDepositData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockDepositDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockDepositData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockDepositData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockDepositData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockWithdrawalDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData) +} + +var vtprotoPool_ClientMeta_AttestationDataSnapshot = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AttestationDataSnapshot{} + }, +} + +func (m *ClientMeta_AttestationDataSnapshot) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ClientMeta_AttestationDataSnapshot) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AttestationDataSnapshot.Put(m) + } +} +func ClientMeta_AttestationDataSnapshotFromVTPool() *ClientMeta_AttestationDataSnapshot { + return vtprotoPool_ClientMeta_AttestationDataSnapshot.Get().(*ClientMeta_AttestationDataSnapshot) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1ValidatorAttestationDataData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1ValidatorAttestationDataData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1ValidatorAttestationDataData) ResetVT() { + if m != nil { + m.Source.ReturnToVTPool() + m.Target.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Snapshot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1ValidatorAttestationDataData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1ValidatorAttestationDataData.Put(m) + } +} +func ClientMeta_AdditionalEthV1ValidatorAttestationDataDataFromVTPool() *ClientMeta_AdditionalEthV1ValidatorAttestationDataData { + return vtprotoPool_ClientMeta_AdditionalEthV1ValidatorAttestationDataData.Get().(*ClientMeta_AdditionalEthV1ValidatorAttestationDataData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsBlobSidecarData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsBlobSidecarData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsBlobSidecarData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsBlobSidecarData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsBlobSidecarData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsBlobSidecarDataFromVTPool() *ClientMeta_AdditionalEthV1EventsBlobSidecarData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsBlobSidecarData.Get().(*ClientMeta_AdditionalEthV1EventsBlobSidecarData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1EventsDataColumnSidecarData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1EventsDataColumnSidecarData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1EventsDataColumnSidecarData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1EventsDataColumnSidecarData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1EventsDataColumnSidecarData.Put(m) + } +} +func ClientMeta_AdditionalEthV1EventsDataColumnSidecarDataFromVTPool() *ClientMeta_AdditionalEthV1EventsDataColumnSidecarData { + return vtprotoPool_ClientMeta_AdditionalEthV1EventsDataColumnSidecarData.Get().(*ClientMeta_AdditionalEthV1EventsDataColumnSidecarData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1BeaconBlobSidecarData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1BeaconBlobSidecarData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobSidecarData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1BeaconBlobSidecarData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1BeaconBlobSidecarData.Put(m) + } +} +func ClientMeta_AdditionalEthV1BeaconBlobSidecarDataFromVTPool() *ClientMeta_AdditionalEthV1BeaconBlobSidecarData { + return vtprotoPool_ClientMeta_AdditionalEthV1BeaconBlobSidecarData.Get().(*ClientMeta_AdditionalEthV1BeaconBlobSidecarData) +} + +var vtprotoPool_ClientMeta_AdditionalBeaconP2PAttestationData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalBeaconP2PAttestationData{} + }, +} + +func (m *ClientMeta_AdditionalBeaconP2PAttestationData) ResetVT() { + if m != nil { + m.Source.ReturnToVTPool() + m.Target.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.AttestingValidator.ReturnToVTPool() + m.Peer.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalBeaconP2PAttestationData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalBeaconP2PAttestationData.Put(m) + } +} +func ClientMeta_AdditionalBeaconP2PAttestationDataFromVTPool() *ClientMeta_AdditionalBeaconP2PAttestationData { + return vtprotoPool_ClientMeta_AdditionalBeaconP2PAttestationData.Get().(*ClientMeta_AdditionalBeaconP2PAttestationData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1ProposerDutyData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1ProposerDutyData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1ProposerDutyData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1ProposerDutyData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1ProposerDutyData.Put(m) + } +} +func ClientMeta_AdditionalEthV1ProposerDutyDataFromVTPool() *ClientMeta_AdditionalEthV1ProposerDutyData { + return vtprotoPool_ClientMeta_AdditionalEthV1ProposerDutyData.Get().(*ClientMeta_AdditionalEthV1ProposerDutyData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData{} + }, +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData) ResetVT() { + if m != nil { + m.Block.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Source.ReturnToVTPool() + m.Target.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData.Put(m) + } +} +func ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationDataFromVTPool() *ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData { + return vtprotoPool_ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData.Get().(*ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceAddPeerData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceAddPeerData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceAddPeerData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceAddPeerData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceAddPeerData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceAddPeerDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceAddPeerData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceAddPeerData.Get().(*ClientMeta_AdditionalLibP2PTraceAddPeerData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRemovePeerData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRemovePeerData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRemovePeerData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRemovePeerData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRemovePeerData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRemovePeerDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRemovePeerData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRemovePeerData.Get().(*ClientMeta_AdditionalLibP2PTraceRemovePeerData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRecvRPCData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRecvRPCData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRecvRPCData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRecvRPCData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRecvRPCData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRecvRPCDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRecvRPCData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRecvRPCData.Get().(*ClientMeta_AdditionalLibP2PTraceRecvRPCData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceSendRPCData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceSendRPCData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceSendRPCData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceSendRPCData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceSendRPCData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceSendRPCDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceSendRPCData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceSendRPCData.Get().(*ClientMeta_AdditionalLibP2PTraceSendRPCData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceDropRPCData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceDropRPCData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceDropRPCData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceDropRPCData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceDropRPCData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceDropRPCDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceDropRPCData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceDropRPCData.Get().(*ClientMeta_AdditionalLibP2PTraceDropRPCData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData.Get().(*ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData.Get().(*ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData.Get().(*ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData.Get().(*ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData.Get().(*ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceJoinData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceJoinData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceJoinData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceJoinData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceJoinData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceJoinDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceJoinData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceJoinData.Get().(*ClientMeta_AdditionalLibP2PTraceJoinData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceLeaveData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceLeaveData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceLeaveData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceLeaveData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceLeaveData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceLeaveDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceLeaveData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceLeaveData.Get().(*ClientMeta_AdditionalLibP2PTraceLeaveData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceGraftData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceGraftData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceGraftData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceGraftData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceGraftData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceGraftDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceGraftData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceGraftData.Get().(*ClientMeta_AdditionalLibP2PTraceGraftData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTracePruneData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTracePruneData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTracePruneData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTracePruneData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTracePruneData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTracePruneDataFromVTPool() *ClientMeta_AdditionalLibP2PTracePruneData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTracePruneData.Get().(*ClientMeta_AdditionalLibP2PTracePruneData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceDuplicateMessageData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceDuplicateMessageData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceDuplicateMessageData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceDuplicateMessageData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceDuplicateMessageData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceDuplicateMessageDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceDuplicateMessageData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceDuplicateMessageData.Get().(*ClientMeta_AdditionalLibP2PTraceDuplicateMessageData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceDeliverMessageData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceDeliverMessageData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceDeliverMessageData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceDeliverMessageData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceDeliverMessageData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceDeliverMessageDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceDeliverMessageData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceDeliverMessageData.Get().(*ClientMeta_AdditionalLibP2PTraceDeliverMessageData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTracePublishMessageData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTracePublishMessageData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTracePublishMessageData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTracePublishMessageData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTracePublishMessageData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTracePublishMessageDataFromVTPool() *ClientMeta_AdditionalLibP2PTracePublishMessageData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTracePublishMessageData.Get().(*ClientMeta_AdditionalLibP2PTracePublishMessageData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRejectMessageData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRejectMessageData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRejectMessageData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRejectMessageData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRejectMessageData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRejectMessageDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRejectMessageData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRejectMessageData.Get().(*ClientMeta_AdditionalLibP2PTraceRejectMessageData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceConnectedData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceConnectedData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceConnectedData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceConnectedData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceConnectedData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceConnectedDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceConnectedData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceConnectedData.Get().(*ClientMeta_AdditionalLibP2PTraceConnectedData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceDisconnectedData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceDisconnectedData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceDisconnectedData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceDisconnectedData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceDisconnectedData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceDisconnectedDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceDisconnectedData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceDisconnectedData.Get().(*ClientMeta_AdditionalLibP2PTraceDisconnectedData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData.Get().(*ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceHandleMetadataData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceHandleMetadataData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleMetadataData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceHandleMetadataData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceHandleMetadataData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceHandleMetadataDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceHandleMetadataData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceHandleMetadataData.Get().(*ClientMeta_AdditionalLibP2PTraceHandleMetadataData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceHandleStatusData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceHandleStatusData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleStatusData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceHandleStatusData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceHandleStatusData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceHandleStatusDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceHandleStatusData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceHandleStatusData.Get().(*ClientMeta_AdditionalLibP2PTraceHandleStatusData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceIdentifyData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceIdentifyData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceIdentifyData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceIdentifyData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceIdentifyData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceIdentifyDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceIdentifyData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceIdentifyData.Get().(*ClientMeta_AdditionalLibP2PTraceIdentifyData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData.Get().(*ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData.Get().(*ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData) ResetVT() { + if m != nil { + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceRPCMetaMessageDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData.Get().(*ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData.Get().(*ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData.Get().(*ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData.Get().(*ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData) ResetVT() { + if m != nil { + m.Source.ReturnToVTPool() + m.Target.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.AttestingValidator.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData.Get().(*ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData.Get().(*ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData.Get().(*ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData) +} + +var vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData{} + }, +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Propagation.ReturnToVTPool() + m.Metadata.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData.Put(m) + } +} +func ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarDataFromVTPool() *ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData { + return vtprotoPool_ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData.Get().(*ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1ValidatorsData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1ValidatorsData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1ValidatorsData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1ValidatorsData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1ValidatorsData.Put(m) + } +} +func ClientMeta_AdditionalEthV1ValidatorsDataFromVTPool() *ClientMeta_AdditionalEthV1ValidatorsData { + return vtprotoPool_ClientMeta_AdditionalEthV1ValidatorsData.Get().(*ClientMeta_AdditionalEthV1ValidatorsData) +} + +var vtprotoPool_ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData{} + }, +} + +func (m *ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData) ResetVT() { + if m != nil { + m.Relay.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData.Put(m) + } +} +func ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionDataFromVTPool() *ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData { + return vtprotoPool_ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData.Get().(*ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData) +} + +var vtprotoPool_ClientMeta_AdditionalMevRelayPayloadDeliveredData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalMevRelayPayloadDeliveredData{} + }, +} + +func (m *ClientMeta_AdditionalMevRelayPayloadDeliveredData) ResetVT() { + if m != nil { + m.Relay.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalMevRelayPayloadDeliveredData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalMevRelayPayloadDeliveredData.Put(m) + } +} +func ClientMeta_AdditionalMevRelayPayloadDeliveredDataFromVTPool() *ClientMeta_AdditionalMevRelayPayloadDeliveredData { + return vtprotoPool_ClientMeta_AdditionalMevRelayPayloadDeliveredData.Get().(*ClientMeta_AdditionalMevRelayPayloadDeliveredData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV3ValidatorBlockData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV3ValidatorBlockData{} + }, +} + +func (m *ClientMeta_AdditionalEthV3ValidatorBlockData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV3ValidatorBlockData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV3ValidatorBlockData.Put(m) + } +} +func ClientMeta_AdditionalEthV3ValidatorBlockDataFromVTPool() *ClientMeta_AdditionalEthV3ValidatorBlockData { + return vtprotoPool_ClientMeta_AdditionalEthV3ValidatorBlockData.Get().(*ClientMeta_AdditionalEthV3ValidatorBlockData) +} + +var vtprotoPool_ClientMeta_AdditionalMevRelayValidatorRegistrationData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalMevRelayValidatorRegistrationData{} + }, +} + +func (m *ClientMeta_AdditionalMevRelayValidatorRegistrationData) ResetVT() { + if m != nil { + m.Relay.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.WallclockSlot.ReturnToVTPool() + m.Epoch.ReturnToVTPool() + m.WallclockEpoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalMevRelayValidatorRegistrationData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalMevRelayValidatorRegistrationData.Put(m) + } +} +func ClientMeta_AdditionalMevRelayValidatorRegistrationDataFromVTPool() *ClientMeta_AdditionalMevRelayValidatorRegistrationData { + return vtprotoPool_ClientMeta_AdditionalMevRelayValidatorRegistrationData.Get().(*ClientMeta_AdditionalMevRelayValidatorRegistrationData) +} + +var vtprotoPool_ClientMeta_AdditionalNodeRecordConsensusData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalNodeRecordConsensusData{} + }, +} + +func (m *ClientMeta_AdditionalNodeRecordConsensusData) ResetVT() { + if m != nil { + m.FinalizedEpoch.ReturnToVTPool() + m.HeadSlot.ReturnToVTPool() + m.HeadEpoch.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalNodeRecordConsensusData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalNodeRecordConsensusData.Put(m) + } +} +func ClientMeta_AdditionalNodeRecordConsensusDataFromVTPool() *ClientMeta_AdditionalNodeRecordConsensusData { + return vtprotoPool_ClientMeta_AdditionalNodeRecordConsensusData.Get().(*ClientMeta_AdditionalNodeRecordConsensusData) +} + +var vtprotoPool_ClientMeta_AdditionalConsensusEngineAPINewPayloadData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalConsensusEngineAPINewPayloadData{} + }, +} + +func (m *ClientMeta_AdditionalConsensusEngineAPINewPayloadData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalConsensusEngineAPINewPayloadData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalConsensusEngineAPINewPayloadData.Put(m) + } +} +func ClientMeta_AdditionalConsensusEngineAPINewPayloadDataFromVTPool() *ClientMeta_AdditionalConsensusEngineAPINewPayloadData { + return vtprotoPool_ClientMeta_AdditionalConsensusEngineAPINewPayloadData.Get().(*ClientMeta_AdditionalConsensusEngineAPINewPayloadData) +} + +var vtprotoPool_ClientMeta_AdditionalConsensusEngineAPIGetBlobsData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalConsensusEngineAPIGetBlobsData{} + }, +} + +func (m *ClientMeta_AdditionalConsensusEngineAPIGetBlobsData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalConsensusEngineAPIGetBlobsData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalConsensusEngineAPIGetBlobsData.Put(m) + } +} +func ClientMeta_AdditionalConsensusEngineAPIGetBlobsDataFromVTPool() *ClientMeta_AdditionalConsensusEngineAPIGetBlobsData { + return vtprotoPool_ClientMeta_AdditionalConsensusEngineAPIGetBlobsData.Get().(*ClientMeta_AdditionalConsensusEngineAPIGetBlobsData) +} + +var vtprotoPool_ClientMeta_AdditionalEthV1BeaconBlobData = sync.Pool{ + New: func() interface{} { + return &ClientMeta_AdditionalEthV1BeaconBlobData{} + }, +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobData) ResetVT() { + if m != nil { + m.Epoch.ReturnToVTPool() + m.Slot.ReturnToVTPool() + m.Reset() + } +} +func (m *ClientMeta_AdditionalEthV1BeaconBlobData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta_AdditionalEthV1BeaconBlobData.Put(m) + } +} +func ClientMeta_AdditionalEthV1BeaconBlobDataFromVTPool() *ClientMeta_AdditionalEthV1BeaconBlobData { + return vtprotoPool_ClientMeta_AdditionalEthV1BeaconBlobData.Get().(*ClientMeta_AdditionalEthV1BeaconBlobData) +} + +var vtprotoPool_ClientMeta = sync.Pool{ + New: func() interface{} { + return &ClientMeta{} + }, +} + +func (m *ClientMeta) ResetVT() { + if m != nil { + m.Ethereum.ReturnToVTPool() + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsAttestation); ok { + oneof.EthV1EventsAttestation.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsHead); ok { + oneof.EthV1EventsHead.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsBlock); ok { + oneof.EthV1EventsBlock.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsVoluntaryExit); ok { + oneof.EthV1EventsVoluntaryExit.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsFinalizedCheckpoint); ok { + oneof.EthV1EventsFinalizedCheckpoint.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsChainReorg); ok { + oneof.EthV1EventsChainReorg.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsContributionAndProof); ok { + oneof.EthV1EventsContributionAndProof.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MempoolTransaction); ok { + oneof.MempoolTransaction.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlock); ok { + oneof.EthV2BeaconBlock.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1DebugForkChoice); ok { + oneof.EthV1DebugForkChoice.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1DebugForkChoiceReorg); ok { + oneof.EthV1DebugForkChoiceReorg.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1BeaconCommittee); ok { + oneof.EthV1BeaconCommittee.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1ValidatorAttestationData); ok { + oneof.EthV1ValidatorAttestationData.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsAttestationV2); ok { + oneof.EthV1EventsAttestationV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsHeadV2); ok { + oneof.EthV1EventsHeadV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsBlockV2); ok { + oneof.EthV1EventsBlockV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsVoluntaryExitV2); ok { + oneof.EthV1EventsVoluntaryExitV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsFinalizedCheckpointV2); ok { + oneof.EthV1EventsFinalizedCheckpointV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsChainReorgV2); ok { + oneof.EthV1EventsChainReorgV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsContributionAndProofV2); ok { + oneof.EthV1EventsContributionAndProofV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MempoolTransactionV2); ok { + oneof.MempoolTransactionV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockV2); ok { + oneof.EthV2BeaconBlockV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1DebugForkChoiceV2); ok { + oneof.EthV1DebugForkChoiceV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1DebugForkChoiceReorgV2); ok { + oneof.EthV1DebugForkChoiceReorgV2.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockAttesterSlashing); ok { + oneof.EthV2BeaconBlockAttesterSlashing.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockProposerSlashing); ok { + oneof.EthV2BeaconBlockProposerSlashing.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockVoluntaryExit); ok { + oneof.EthV2BeaconBlockVoluntaryExit.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockDeposit); ok { + oneof.EthV2BeaconBlockDeposit.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockBlsToExecutionChange); ok { + oneof.EthV2BeaconBlockBlsToExecutionChange.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockExecutionTransaction); ok { + oneof.EthV2BeaconBlockExecutionTransaction.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockWithdrawal); ok { + oneof.EthV2BeaconBlockWithdrawal.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsBlobSidecar); ok { + oneof.EthV1EventsBlobSidecar.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1BeaconBlobSidecar); ok { + oneof.EthV1BeaconBlobSidecar.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_BeaconP2PAttestation); ok { + oneof.BeaconP2PAttestation.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1ProposerDuty); ok { + oneof.EthV1ProposerDuty.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockElaboratedAttestation); ok { + oneof.EthV2BeaconBlockElaboratedAttestation.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceAddPeer); ok { + oneof.Libp2PTraceAddPeer.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRemovePeer); ok { + oneof.Libp2PTraceRemovePeer.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRecvRpc); ok { + oneof.Libp2PTraceRecvRpc.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceSendRpc); ok { + oneof.Libp2PTraceSendRpc.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceJoin); ok { + oneof.Libp2PTraceJoin.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceConnected); ok { + oneof.Libp2PTraceConnected.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceDisconnected); ok { + oneof.Libp2PTraceDisconnected.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceHandleMetadata); ok { + oneof.Libp2PTraceHandleMetadata.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceHandleStatus); ok { + oneof.Libp2PTraceHandleStatus.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubBeaconBlock); ok { + oneof.Libp2PTraceGossipsubBeaconBlock.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubBeaconAttestation); ok { + oneof.Libp2PTraceGossipsubBeaconAttestation.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubBlobSidecar); ok { + oneof.Libp2PTraceGossipsubBlobSidecar.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1Validators); ok { + oneof.EthV1Validators.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MevRelayBidTraceBuilderBlockSubmission); ok { + oneof.MevRelayBidTraceBuilderBlockSubmission.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MevRelayPayloadDelivered); ok { + oneof.MevRelayPayloadDelivered.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV3ValidatorBlock); ok { + oneof.EthV3ValidatorBlock.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MevRelayValidatorRegistration); ok { + oneof.MevRelayValidatorRegistration.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsBlockGossip); ok { + oneof.EthV1EventsBlockGossip.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceDropRpc); ok { + oneof.Libp2PTraceDropRpc.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceLeave); ok { + oneof.Libp2PTraceLeave.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGraft); ok { + oneof.Libp2PTraceGraft.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTracePrune); ok { + oneof.Libp2PTracePrune.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceDuplicateMessage); ok { + oneof.Libp2PTraceDuplicateMessage.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceDeliverMessage); ok { + oneof.Libp2PTraceDeliverMessage.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTracePublishMessage); ok { + oneof.Libp2PTracePublishMessage.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRejectMessage); ok { + oneof.Libp2PTraceRejectMessage.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlIhave); ok { + oneof.Libp2PTraceRpcMetaControlIhave.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlIwant); ok { + oneof.Libp2PTraceRpcMetaControlIwant.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlIdontwant); ok { + oneof.Libp2PTraceRpcMetaControlIdontwant.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlGraft); ok { + oneof.Libp2PTraceRpcMetaControlGraft.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlPrune); ok { + oneof.Libp2PTraceRpcMetaControlPrune.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaSubscription); ok { + oneof.Libp2PTraceRpcMetaSubscription.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaMessage); ok { + oneof.Libp2PTraceRpcMetaMessage.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_NodeRecordConsensus); ok { + oneof.NodeRecordConsensus.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubAggregateAndProof); ok { + oneof.Libp2PTraceGossipsubAggregateAndProof.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsDataColumnSidecar); ok { + oneof.EthV1EventsDataColumnSidecar.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubDataColumnSidecar); ok { + oneof.Libp2PTraceGossipsubDataColumnSidecar.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceSyntheticHeartbeat); ok { + oneof.Libp2PTraceSyntheticHeartbeat.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcDataColumnCustodyProbe); ok { + oneof.Libp2PTraceRpcDataColumnCustodyProbe.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_ConsensusEngineApiNewPayload); ok { + oneof.ConsensusEngineApiNewPayload.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_ConsensusEngineApiGetBlobs); ok { + oneof.ConsensusEngineApiGetBlobs.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1BeaconBlob); ok { + oneof.EthV1BeaconBlob.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1BeaconSyncCommittee); ok { + oneof.EthV1BeaconSyncCommittee.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockSyncAggregate); ok { + oneof.EthV2BeaconBlockSyncAggregate.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceIdentify); ok { + oneof.Libp2PTraceIdentify.ReturnToVTPool() + } + m.Reset() + } +} +func (m *ClientMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ClientMeta.Put(m) + } +} +func ClientMetaFromVTPool() *ClientMeta { + return vtprotoPool_ClientMeta.Get().(*ClientMeta) +} + +var vtprotoPool_ServerMeta_Event = sync.Pool{ + New: func() interface{} { + return &ServerMeta_Event{} + }, +} + +func (m *ServerMeta_Event) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ServerMeta_Event) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_Event.Put(m) + } +} +func ServerMeta_EventFromVTPool() *ServerMeta_Event { + return vtprotoPool_ServerMeta_Event.Get().(*ServerMeta_Event) +} + +var vtprotoPool_ServerMeta_Geo = sync.Pool{ + New: func() interface{} { + return &ServerMeta_Geo{} + }, +} + +func (m *ServerMeta_Geo) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ServerMeta_Geo) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_Geo.Put(m) + } +} +func ServerMeta_GeoFromVTPool() *ServerMeta_Geo { + return vtprotoPool_ServerMeta_Geo.Get().(*ServerMeta_Geo) +} + +var vtprotoPool_ServerMeta_Client = sync.Pool{ + New: func() interface{} { + return &ServerMeta_Client{} + }, +} + +func (m *ServerMeta_Client) ResetVT() { + if m != nil { + m.Geo.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_Client) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_Client.Put(m) + } +} +func ServerMeta_ClientFromVTPool() *ServerMeta_Client { + return vtprotoPool_ServerMeta_Client.Get().(*ServerMeta_Client) +} + +var vtprotoPool_ServerMeta_Peer = sync.Pool{ + New: func() interface{} { + return &ServerMeta_Peer{} + }, +} + +func (m *ServerMeta_Peer) ResetVT() { + if m != nil { + m.Geo.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_Peer) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_Peer.Put(m) + } +} +func ServerMeta_PeerFromVTPool() *ServerMeta_Peer { + return vtprotoPool_ServerMeta_Peer.Get().(*ServerMeta_Peer) +} + +var vtprotoPool_ServerMeta_AdditionalBeaconP2PAttestationData = sync.Pool{ + New: func() interface{} { + return &ServerMeta_AdditionalBeaconP2PAttestationData{} + }, +} + +func (m *ServerMeta_AdditionalBeaconP2PAttestationData) ResetVT() { + if m != nil { + m.Peer.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_AdditionalBeaconP2PAttestationData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_AdditionalBeaconP2PAttestationData.Put(m) + } +} +func ServerMeta_AdditionalBeaconP2PAttestationDataFromVTPool() *ServerMeta_AdditionalBeaconP2PAttestationData { + return vtprotoPool_ServerMeta_AdditionalBeaconP2PAttestationData.Get().(*ServerMeta_AdditionalBeaconP2PAttestationData) +} + +var vtprotoPool_ServerMeta_AdditionalLibp2PTraceConnectedData = sync.Pool{ + New: func() interface{} { + return &ServerMeta_AdditionalLibp2PTraceConnectedData{} + }, +} + +func (m *ServerMeta_AdditionalLibp2PTraceConnectedData) ResetVT() { + if m != nil { + m.Peer.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_AdditionalLibp2PTraceConnectedData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_AdditionalLibp2PTraceConnectedData.Put(m) + } +} +func ServerMeta_AdditionalLibp2PTraceConnectedDataFromVTPool() *ServerMeta_AdditionalLibp2PTraceConnectedData { + return vtprotoPool_ServerMeta_AdditionalLibp2PTraceConnectedData.Get().(*ServerMeta_AdditionalLibp2PTraceConnectedData) +} + +var vtprotoPool_ServerMeta_AdditionalLibp2PTraceDisconnectedData = sync.Pool{ + New: func() interface{} { + return &ServerMeta_AdditionalLibp2PTraceDisconnectedData{} + }, +} + +func (m *ServerMeta_AdditionalLibp2PTraceDisconnectedData) ResetVT() { + if m != nil { + m.Peer.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_AdditionalLibp2PTraceDisconnectedData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_AdditionalLibp2PTraceDisconnectedData.Put(m) + } +} +func ServerMeta_AdditionalLibp2PTraceDisconnectedDataFromVTPool() *ServerMeta_AdditionalLibp2PTraceDisconnectedData { + return vtprotoPool_ServerMeta_AdditionalLibp2PTraceDisconnectedData.Get().(*ServerMeta_AdditionalLibp2PTraceDisconnectedData) +} + +var vtprotoPool_ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData = sync.Pool{ + New: func() interface{} { + return &ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData{} + }, +} + +func (m *ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) ResetVT() { + if m != nil { + m.Peer.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData.Put(m) + } +} +func ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatDataFromVTPool() *ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData { + return vtprotoPool_ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData.Get().(*ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) +} + +var vtprotoPool_ServerMeta_AdditionalLibp2PTraceIdentifyData = sync.Pool{ + New: func() interface{} { + return &ServerMeta_AdditionalLibp2PTraceIdentifyData{} + }, +} + +func (m *ServerMeta_AdditionalLibp2PTraceIdentifyData) ResetVT() { + if m != nil { + m.Peer.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_AdditionalLibp2PTraceIdentifyData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_AdditionalLibp2PTraceIdentifyData.Put(m) + } +} +func ServerMeta_AdditionalLibp2PTraceIdentifyDataFromVTPool() *ServerMeta_AdditionalLibp2PTraceIdentifyData { + return vtprotoPool_ServerMeta_AdditionalLibp2PTraceIdentifyData.Get().(*ServerMeta_AdditionalLibp2PTraceIdentifyData) +} + +var vtprotoPool_ServerMeta_AdditionalNodeRecordConsensusData = sync.Pool{ + New: func() interface{} { + return &ServerMeta_AdditionalNodeRecordConsensusData{} + }, +} + +func (m *ServerMeta_AdditionalNodeRecordConsensusData) ResetVT() { + if m != nil { + m.Geo.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_AdditionalNodeRecordConsensusData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_AdditionalNodeRecordConsensusData.Put(m) + } +} +func ServerMeta_AdditionalNodeRecordConsensusDataFromVTPool() *ServerMeta_AdditionalNodeRecordConsensusData { + return vtprotoPool_ServerMeta_AdditionalNodeRecordConsensusData.Get().(*ServerMeta_AdditionalNodeRecordConsensusData) +} + +var vtprotoPool_ServerMeta_AdditionalNodeRecordExecutionData = sync.Pool{ + New: func() interface{} { + return &ServerMeta_AdditionalNodeRecordExecutionData{} + }, +} + +func (m *ServerMeta_AdditionalNodeRecordExecutionData) ResetVT() { + if m != nil { + m.Geo.ReturnToVTPool() + m.Reset() + } +} +func (m *ServerMeta_AdditionalNodeRecordExecutionData) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta_AdditionalNodeRecordExecutionData.Put(m) + } +} +func ServerMeta_AdditionalNodeRecordExecutionDataFromVTPool() *ServerMeta_AdditionalNodeRecordExecutionData { + return vtprotoPool_ServerMeta_AdditionalNodeRecordExecutionData.Get().(*ServerMeta_AdditionalNodeRecordExecutionData) +} + +var vtprotoPool_ServerMeta = sync.Pool{ + New: func() interface{} { + return &ServerMeta{} + }, +} + +func (m *ServerMeta) ResetVT() { + if m != nil { + m.Event.ReturnToVTPool() + m.Client.ReturnToVTPool() + if oneof, ok := m.AdditionalData.(*ServerMeta_BEACON_P2P_ATTESTATION); ok { + oneof.BEACON_P2P_ATTESTATION.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ServerMeta_LIBP2P_TRACE_CONNECTED); ok { + oneof.LIBP2P_TRACE_CONNECTED.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ServerMeta_LIBP2P_TRACE_DISCONNECTED); ok { + oneof.LIBP2P_TRACE_DISCONNECTED.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ServerMeta_NODE_RECORD_CONSENSUS); ok { + oneof.NODE_RECORD_CONSENSUS.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ServerMeta_NODE_RECORD_EXECUTION); ok { + oneof.NODE_RECORD_EXECUTION.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ServerMeta_LIBP2P_TRACE_SYNTHETIC_HEARTBEAT); ok { + oneof.LIBP2P_TRACE_SYNTHETIC_HEARTBEAT.ReturnToVTPool() + } + if oneof, ok := m.AdditionalData.(*ServerMeta_LIBP2P_TRACE_IDENTIFY); ok { + oneof.LIBP2P_TRACE_IDENTIFY.ReturnToVTPool() + } + m.Reset() + } +} +func (m *ServerMeta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ServerMeta.Put(m) + } +} +func ServerMetaFromVTPool() *ServerMeta { + return vtprotoPool_ServerMeta.Get().(*ServerMeta) +} + +var vtprotoPool_Meta = sync.Pool{ + New: func() interface{} { + return &Meta{} + }, +} + +func (m *Meta) ResetVT() { + if m != nil { + m.Client.ReturnToVTPool() + m.Server.ReturnToVTPool() + m.Reset() + } +} +func (m *Meta) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Meta.Put(m) + } +} +func MetaFromVTPool() *Meta { + return vtprotoPool_Meta.Get().(*Meta) +} + +var vtprotoPool_Event = sync.Pool{ + New: func() interface{} { + return &Event{} + }, +} + +func (m *Event) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *Event) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_Event.Put(m) + } +} +func EventFromVTPool() *Event { + return vtprotoPool_Event.Get().(*Event) +} + +var vtprotoPool_ExecutionBlockMetrics_StateReads = sync.Pool{ + New: func() interface{} { + return &ExecutionBlockMetrics_StateReads{} + }, +} + +func (m *ExecutionBlockMetrics_StateReads) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionBlockMetrics_StateReads) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionBlockMetrics_StateReads.Put(m) + } +} +func ExecutionBlockMetrics_StateReadsFromVTPool() *ExecutionBlockMetrics_StateReads { + return vtprotoPool_ExecutionBlockMetrics_StateReads.Get().(*ExecutionBlockMetrics_StateReads) +} + +var vtprotoPool_ExecutionBlockMetrics_StateWrites = sync.Pool{ + New: func() interface{} { + return &ExecutionBlockMetrics_StateWrites{} + }, +} + +func (m *ExecutionBlockMetrics_StateWrites) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionBlockMetrics_StateWrites) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionBlockMetrics_StateWrites.Put(m) + } +} +func ExecutionBlockMetrics_StateWritesFromVTPool() *ExecutionBlockMetrics_StateWrites { + return vtprotoPool_ExecutionBlockMetrics_StateWrites.Get().(*ExecutionBlockMetrics_StateWrites) +} + +var vtprotoPool_ExecutionBlockMetrics_CacheEntry = sync.Pool{ + New: func() interface{} { + return &ExecutionBlockMetrics_CacheEntry{} + }, +} + +func (m *ExecutionBlockMetrics_CacheEntry) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionBlockMetrics_CacheEntry) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionBlockMetrics_CacheEntry.Put(m) + } +} +func ExecutionBlockMetrics_CacheEntryFromVTPool() *ExecutionBlockMetrics_CacheEntry { + return vtprotoPool_ExecutionBlockMetrics_CacheEntry.Get().(*ExecutionBlockMetrics_CacheEntry) +} + +var vtprotoPool_ExecutionBlockMetrics_CodeCacheEntry = sync.Pool{ + New: func() interface{} { + return &ExecutionBlockMetrics_CodeCacheEntry{} + }, +} + +func (m *ExecutionBlockMetrics_CodeCacheEntry) ResetVT() { + if m != nil { + m.Reset() + } +} +func (m *ExecutionBlockMetrics_CodeCacheEntry) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionBlockMetrics_CodeCacheEntry.Put(m) + } +} +func ExecutionBlockMetrics_CodeCacheEntryFromVTPool() *ExecutionBlockMetrics_CodeCacheEntry { + return vtprotoPool_ExecutionBlockMetrics_CodeCacheEntry.Get().(*ExecutionBlockMetrics_CodeCacheEntry) +} + +var vtprotoPool_ExecutionBlockMetrics = sync.Pool{ + New: func() interface{} { + return &ExecutionBlockMetrics{} + }, +} + +func (m *ExecutionBlockMetrics) ResetVT() { + if m != nil { + m.StateReads.ReturnToVTPool() + m.StateWrites.ReturnToVTPool() + m.AccountCache.ReturnToVTPool() + m.StorageCache.ReturnToVTPool() + m.CodeCache.ReturnToVTPool() + m.Reset() + } +} +func (m *ExecutionBlockMetrics) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_ExecutionBlockMetrics.Put(m) + } +} +func ExecutionBlockMetricsFromVTPool() *ExecutionBlockMetrics { + return vtprotoPool_ExecutionBlockMetrics.Get().(*ExecutionBlockMetrics) +} + +var vtprotoPool_DecoratedEvent = sync.Pool{ + New: func() interface{} { + return &DecoratedEvent{} + }, +} + +func (m *DecoratedEvent) ResetVT() { + if m != nil { + m.Event.ReturnToVTPool() + m.Meta.ReturnToVTPool() + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsAttestation); ok { + oneof.EthV1EventsAttestation.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsBlock); ok { + oneof.EthV1EventsBlock.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsChainReorg); ok { + oneof.EthV1EventsChainReorg.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsFinalizedCheckpoint); ok { + oneof.EthV1EventsFinalizedCheckpoint.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsHead); ok { + oneof.EthV1EventsHead.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsVoluntaryExit); ok { + oneof.EthV1EventsVoluntaryExit.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsContributionAndProof); ok { + oneof.EthV1EventsContributionAndProof.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlock); ok { + oneof.EthV2BeaconBlock.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ForkChoice); ok { + oneof.EthV1ForkChoice.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ForkChoiceReorg); ok { + oneof.EthV1ForkChoiceReorg.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1BeaconCommittee); ok { + oneof.EthV1BeaconCommittee.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ValidatorAttestationData); ok { + oneof.EthV1ValidatorAttestationData.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsAttestationV2); ok { + oneof.EthV1EventsAttestationV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsBlockV2); ok { + oneof.EthV1EventsBlockV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsChainReorgV2); ok { + oneof.EthV1EventsChainReorgV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsFinalizedCheckpointV2); ok { + oneof.EthV1EventsFinalizedCheckpointV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsHeadV2); ok { + oneof.EthV1EventsHeadV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsVoluntaryExitV2); ok { + oneof.EthV1EventsVoluntaryExitV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsContributionAndProofV2); ok { + oneof.EthV1EventsContributionAndProofV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockV2); ok { + oneof.EthV2BeaconBlockV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ForkChoiceV2); ok { + oneof.EthV1ForkChoiceV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ForkChoiceReorgV2); ok { + oneof.EthV1ForkChoiceReorgV2.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockAttesterSlashing); ok { + oneof.EthV2BeaconBlockAttesterSlashing.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockProposerSlashing); ok { + oneof.EthV2BeaconBlockProposerSlashing.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockVoluntaryExit); ok { + oneof.EthV2BeaconBlockVoluntaryExit.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockDeposit); ok { + oneof.EthV2BeaconBlockDeposit.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockBlsToExecutionChange); ok { + oneof.EthV2BeaconBlockBlsToExecutionChange.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockExecutionTransaction); ok { + oneof.EthV2BeaconBlockExecutionTransaction.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockWithdrawal); ok { + oneof.EthV2BeaconBlockWithdrawal.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsBlobSidecar); ok { + oneof.EthV1EventsBlobSidecar.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1BeaconBlockBlobSidecar); ok { + oneof.EthV1BeaconBlockBlobSidecar.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_BeaconP2PAttestation); ok { + oneof.BeaconP2PAttestation.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ProposerDuty); ok { + oneof.EthV1ProposerDuty.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockElaboratedAttestation); ok { + oneof.EthV2BeaconBlockElaboratedAttestation.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceAddPeer); ok { + oneof.Libp2PTraceAddPeer.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRemovePeer); ok { + oneof.Libp2PTraceRemovePeer.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRecvRpc); ok { + oneof.Libp2PTraceRecvRpc.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceSendRpc); ok { + oneof.Libp2PTraceSendRpc.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceJoin); ok { + oneof.Libp2PTraceJoin.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceConnected); ok { + oneof.Libp2PTraceConnected.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceDisconnected); ok { + oneof.Libp2PTraceDisconnected.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceHandleMetadata); ok { + oneof.Libp2PTraceHandleMetadata.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceHandleStatus); ok { + oneof.Libp2PTraceHandleStatus.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubBeaconBlock); ok { + oneof.Libp2PTraceGossipsubBeaconBlock.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubBeaconAttestation); ok { + oneof.Libp2PTraceGossipsubBeaconAttestation.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubBlobSidecar); ok { + oneof.Libp2PTraceGossipsubBlobSidecar.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1Validators); ok { + oneof.EthV1Validators.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_MevRelayBidTraceBuilderBlockSubmission); ok { + oneof.MevRelayBidTraceBuilderBlockSubmission.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_MevRelayPayloadDelivered); ok { + oneof.MevRelayPayloadDelivered.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV3ValidatorBlock); ok { + oneof.EthV3ValidatorBlock.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_MevRelayValidatorRegistration); ok { + oneof.MevRelayValidatorRegistration.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsBlockGossip); ok { + oneof.EthV1EventsBlockGossip.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceDropRpc); ok { + oneof.Libp2PTraceDropRpc.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceLeave); ok { + oneof.Libp2PTraceLeave.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGraft); ok { + oneof.Libp2PTraceGraft.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTracePrune); ok { + oneof.Libp2PTracePrune.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceDuplicateMessage); ok { + oneof.Libp2PTraceDuplicateMessage.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceDeliverMessage); ok { + oneof.Libp2PTraceDeliverMessage.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTracePublishMessage); ok { + oneof.Libp2PTracePublishMessage.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRejectMessage); ok { + oneof.Libp2PTraceRejectMessage.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlIhave); ok { + oneof.Libp2PTraceRpcMetaControlIhave.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlIwant); ok { + oneof.Libp2PTraceRpcMetaControlIwant.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlIdontwant); ok { + oneof.Libp2PTraceRpcMetaControlIdontwant.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlGraft); ok { + oneof.Libp2PTraceRpcMetaControlGraft.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlPrune); ok { + oneof.Libp2PTraceRpcMetaControlPrune.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaSubscription); ok { + oneof.Libp2PTraceRpcMetaSubscription.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaMessage); ok { + oneof.Libp2PTraceRpcMetaMessage.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_NodeRecordConsensus); ok { + oneof.NodeRecordConsensus.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_NodeRecordExecution); ok { + oneof.NodeRecordExecution.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubAggregateAndProof); ok { + oneof.Libp2PTraceGossipsubAggregateAndProof.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsDataColumnSidecar); ok { + oneof.EthV1EventsDataColumnSidecar.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubDataColumnSidecar); ok { + oneof.Libp2PTraceGossipsubDataColumnSidecar.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceSyntheticHeartbeat); ok { + oneof.Libp2PTraceSyntheticHeartbeat.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceIdentify); ok { + oneof.Libp2PTraceIdentify.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcDataColumnCustodyProbe); ok { + oneof.Libp2PTraceRpcDataColumnCustodyProbe.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_ExecutionStateSize); ok { + oneof.ExecutionStateSize.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_ConsensusEngineApiNewPayload); ok { + oneof.ConsensusEngineApiNewPayload.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_ConsensusEngineApiGetBlobs); ok { + oneof.ConsensusEngineApiGetBlobs.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_ExecutionEngineNewPayload); ok { + oneof.ExecutionEngineNewPayload.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_ExecutionEngineGetBlobs); ok { + oneof.ExecutionEngineGetBlobs.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1BeaconBlob); ok { + oneof.EthV1BeaconBlob.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1BeaconSyncCommittee); ok { + oneof.EthV1BeaconSyncCommittee.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockSyncAggregate); ok { + oneof.EthV2BeaconBlockSyncAggregate.ReturnToVTPool() + } + if oneof, ok := m.Data.(*DecoratedEvent_ExecutionBlockMetrics); ok { + oneof.ExecutionBlockMetrics.ReturnToVTPool() + } + m.Reset() + } +} +func (m *DecoratedEvent) ReturnToVTPool() { + if m != nil { + m.ResetVT() + vtprotoPool_DecoratedEvent.Put(m) + } +} +func DecoratedEventFromVTPool() *DecoratedEvent { + return vtprotoPool_DecoratedEvent.Get().(*DecoratedEvent) +} +func (m *CreateEventsRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Events) > 0 { + for _, e := range m.Events { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *CreateEventsResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EventsIngested != nil { + l = (*wrapperspb.UInt64Value)(m.EventsIngested).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Epoch) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Number != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Number)) + } + if m.StartDateTime != nil { + l = (*timestamppb.Timestamp)(m.StartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *EpochV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Number != nil { + l = (*wrapperspb.UInt64Value)(m.Number).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StartDateTime != nil { + l = (*timestamppb.Timestamp)(m.StartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Slot) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Number != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Number)) + } + if m.StartDateTime != nil { + l = (*timestamppb.Timestamp)(m.StartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SlotV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Number != nil { + l = (*wrapperspb.UInt64Value)(m.Number).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StartDateTime != nil { + l = (*timestamppb.Timestamp)(m.StartDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ForkID) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Next) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Propagation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SlotStartDiff != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.SlotStartDiff)) + } + n += len(m.unknownFields) + return n +} + +func (m *PropagationV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SlotStartDiff != nil { + l = (*wrapperspb.UInt64Value)(m.SlotStartDiff).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *AttestingValidator) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CommitteeIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.CommitteeIndex)) + } + if m.Index != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Index)) + } + n += len(m.unknownFields) + return n +} + +func (m *AttestingValidatorV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CommitteeIndex != nil { + l = (*wrapperspb.UInt64Value)(m.CommitteeIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Index != nil { + l = (*wrapperspb.UInt64Value)(m.Index).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DebugForkChoiceReorg) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Before != nil { + l = m.Before.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.After != nil { + l = m.After.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Event != nil { + l = m.Event.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DebugForkChoiceReorgV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Before != nil { + l = m.Before.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.After != nil { + l = m.After.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Event != nil { + l = m.Event.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Validators) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Validators) > 0 { + for _, e := range m.Validators { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *SyncCommitteeData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SyncCommittee != nil { + l = m.SyncCommittee.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SyncAggregateData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SyncCommitteeBits) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SyncCommitteeSignature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ValidatorsParticipated) > 0 { + for _, e := range m.ValidatorsParticipated { + l = (*wrapperspb.UInt64Value)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.ValidatorsMissed) > 0 { + for _, e := range m.ValidatorsMissed { + l = (*wrapperspb.UInt64Value)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ParticipationCount != nil { + l = (*wrapperspb.UInt64Value)(m.ParticipationCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlockIdentifier) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Root) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionStateSize) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.AccountBytes) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.AccountTrienodeBytes) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.AccountTrienodes) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Accounts) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockNumber) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ContractCodeBytes) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ContractCodes) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StorageBytes) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StorageTrienodeBytes) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StorageTrienodes) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Storages) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ConsensusEngineAPINewPayload) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestedAt != nil { + l = (*timestamppb.Timestamp)(m.RequestedAt).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DurationMs != nil { + l = (*wrapperspb.UInt64Value)(m.DurationMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentBlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProposerIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ProposerIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TxCount != nil { + l = (*wrapperspb.UInt32Value)(m.TxCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlobCount != nil { + l = (*wrapperspb.UInt32Value)(m.BlobCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Status) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LatestValidHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ValidationError) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.MethodVersion) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ConsensusEngineAPIGetBlobs) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestedAt != nil { + l = (*timestamppb.Timestamp)(m.RequestedAt).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DurationMs != nil { + l = (*wrapperspb.UInt64Value)(m.DurationMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = (*wrapperspb.UInt64Value)(m.Slot).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentBlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestedCount != nil { + l = (*wrapperspb.UInt32Value)(m.RequestedCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.VersionedHashes) > 0 { + for _, s := range m.VersionedHashes { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ReturnedCount != nil { + l = (*wrapperspb.UInt32Value)(m.ReturnedCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Status) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ErrorMessage) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.MethodVersion) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionEngineNewPayload) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Source)) + } + if m.RequestedAt != nil { + l = (*timestamppb.Timestamp)(m.RequestedAt).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DurationMs != nil { + l = (*wrapperspb.UInt64Value)(m.DurationMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ParentHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasLimit != nil { + l = (*wrapperspb.UInt64Value)(m.GasLimit).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TxCount != nil { + l = (*wrapperspb.UInt32Value)(m.TxCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlobCount != nil { + l = (*wrapperspb.UInt32Value)(m.BlobCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Status) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LatestValidHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ValidationError) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.MethodVersion) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionEngineGetBlobs) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Source)) + } + if m.RequestedAt != nil { + l = (*timestamppb.Timestamp)(m.RequestedAt).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DurationMs != nil { + l = (*wrapperspb.UInt64Value)(m.DurationMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestedCount != nil { + l = (*wrapperspb.UInt32Value)(m.RequestedCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.VersionedHashes) > 0 { + for _, s := range m.VersionedHashes { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ReturnedCount != nil { + l = (*wrapperspb.UInt32Value)(m.ReturnedCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Status) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ErrorMessage) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.MethodVersion) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ReturnedBlobIndexes) > 0 { + for _, e := range m.ReturnedBlobIndexes { + l = (*wrapperspb.UInt32Value)(e).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_Ethereum_Network) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Id != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Id)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_Ethereum_Execution) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ForkId != nil { + l = m.ForkId.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Implementation) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.VersionMajor) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.VersionMinor) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.VersionPatch) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_Ethereum_Consensus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Implementation) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_Ethereum) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Network != nil { + l = m.Network.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Execution != nil { + l = m.Execution.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Consensus != nil { + l = m.Consensus.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1AttestationSourceV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1AttestationTargetV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Target != nil { + l = m.Target.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AttestingValidator != nil { + l = m.AttestingValidator.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsAttestationV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Target != nil { + l = m.Target.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AttestingValidator != nil { + l = m.AttestingValidator.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsHeadV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsBlockGossipData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsChainReorgV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Contribution != nil { + l = m.Contribution.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Contribution != nil { + l = m.Contribution.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_ForkChoiceSnapshot) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestEpoch != nil { + l = m.RequestEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestSlot != nil { + l = m.RequestSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestedAtSlotStartDiffMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.RequestedAtSlotStartDiffMs)) + } + if m.RequestDurationMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.RequestDurationMs)) + } + if m.Timestamp != nil { + l = (*timestamppb.Timestamp)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_ForkChoiceSnapshotV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestEpoch != nil { + l = m.RequestEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestSlot != nil { + l = m.RequestSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestedAtSlotStartDiffMs != nil { + l = (*wrapperspb.UInt64Value)(m.RequestedAtSlotStartDiffMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestDurationMs != nil { + l = (*wrapperspb.UInt64Value)(m.RequestDurationMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*timestamppb.Timestamp)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Snapshot != nil { + l = m.Snapshot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Snapshot != nil { + l = m.Snapshot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Before != nil { + l = m.Before.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.After != nil { + l = m.After.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Before != nil { + l = m.Before.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.After != nil { + l = m.After.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1BeaconCommitteeData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1BeaconSyncCommitteeData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SyncCommitteePeriod != nil { + l = (*wrapperspb.UInt64Value)(m.SyncCommitteePeriod).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SyncCommitteePeriod != nil { + l = (*wrapperspb.UInt64Value)(m.SyncCommitteePeriod).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalMempoolTransactionData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.From) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.To) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Nonce != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Nonce)) + } + l = len(m.GasPrice) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Gas != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Gas)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Size) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.CallDataSize) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalMempoolTransactionV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.From) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.To) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Nonce != nil { + l = (*wrapperspb.UInt64Value)(m.Nonce).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.GasPrice) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Gas != nil { + l = (*wrapperspb.UInt64Value)(m.Gas).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Size) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.CallDataSize) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Type != nil { + l = (*wrapperspb.UInt32Value)(m.Type).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.GasTipCap) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.GasFeeCap) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlobGas != nil { + l = (*wrapperspb.UInt64Value)(m.BlobGas).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlobGasFeeCap) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.BlobHashes) > 0 { + for _, s := range m.BlobHashes { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + l = len(m.BlobSidecarsSize) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlobSidecarsEmptySize) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TransactionsCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TransactionsCount)) + } + if m.TransactionsTotalBytes != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TransactionsTotalBytes)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockV2Data) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockRoot) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TransactionsCount != nil { + l = (*wrapperspb.UInt64Value)(m.TransactionsCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TransactionsTotalBytes != nil { + l = (*wrapperspb.UInt64Value)(m.TransactionsTotalBytes).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TransactionsTotalBytesCompressed != nil { + l = (*wrapperspb.UInt64Value)(m.TransactionsTotalBytesCompressed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TotalBytes != nil { + l = (*wrapperspb.UInt64Value)(m.TotalBytes).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TotalBytesCompressed != nil { + l = (*wrapperspb.UInt64Value)(m.TotalBytesCompressed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalizedWhenRequested { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockDepositData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PositionInBlock != nil { + l = (*wrapperspb.UInt64Value)(m.PositionInBlock).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Size) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.CallDataSize) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlobSidecarsSize) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlobSidecarsEmptySize) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AttestationDataSnapshot) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestedAtSlotStartDiffMs != nil { + l = (*wrapperspb.UInt64Value)(m.RequestedAtSlotStartDiffMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestDurationMs != nil { + l = (*wrapperspb.UInt64Value)(m.RequestDurationMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Timestamp != nil { + l = (*timestamppb.Timestamp)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1ValidatorAttestationDataData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Target != nil { + l = m.Target.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Snapshot != nil { + l = m.Snapshot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsBlobSidecarData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1EventsDataColumnSidecarData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobSidecarData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DataSize != nil { + l = (*wrapperspb.UInt64Value)(m.DataSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.VersionedHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DataEmptySize != nil { + l = (*wrapperspb.UInt64Value)(m.DataEmptySize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalBeaconP2PAttestationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Target != nil { + l = m.Target.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AttestingValidator != nil { + l = m.AttestingValidator.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Peer != nil { + l = m.Peer.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Subnet != nil { + l = (*wrapperspb.UInt32Value)(m.Subnet).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Validated != nil { + l = (*wrapperspb.BoolValue)(m.Validated).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1ProposerDutyData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Block != nil { + l = m.Block.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PositionInBlock != nil { + l = (*wrapperspb.UInt64Value)(m.PositionInBlock).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Target != nil { + l = m.Target.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceAddPeerData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRemovePeerData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRecvRPCData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceSendRPCData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceDropRPCData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceJoinData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceLeaveData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceGraftData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTracePruneData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceDuplicateMessageData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceDeliverMessageData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTracePublishMessageData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRejectMessageData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceConnectedData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceDisconnectedData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleMetadataData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceHandleStatusData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceIdentifyData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageSize != nil { + l = (*wrapperspb.UInt32Value)(m.MessageSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Target != nil { + l = m.Target.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AttestingValidator != nil { + l = m.AttestingValidator.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageSize != nil { + l = (*wrapperspb.UInt32Value)(m.MessageSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AggregatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.AggregatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageSize != nil { + l = (*wrapperspb.UInt32Value)(m.MessageSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageSize != nil { + l = (*wrapperspb.UInt32Value)(m.MessageSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Propagation != nil { + l = m.Propagation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Metadata != nil { + l = m.Metadata.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Topic != nil { + l = (*wrapperspb.StringValue)(m.Topic).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageSize != nil { + l = (*wrapperspb.UInt32Value)(m.MessageSize).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MessageId != nil { + l = (*wrapperspb.StringValue)(m.MessageId).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1ValidatorsData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Relay != nil { + l = m.Relay.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestedAtSlotTime != nil { + l = (*wrapperspb.UInt64Value)(m.RequestedAtSlotTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ResponseAtSlotTime != nil { + l = (*wrapperspb.UInt64Value)(m.ResponseAtSlotTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalMevRelayPayloadDeliveredData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Relay != nil { + l = m.Relay.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestedAtSlotTime != nil { + l = (*wrapperspb.UInt64Value)(m.RequestedAtSlotTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ResponseAtSlotTime != nil { + l = (*wrapperspb.UInt64Value)(m.ResponseAtSlotTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV3ValidatorBlockData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TransactionsCount != nil { + l = (*wrapperspb.UInt64Value)(m.TransactionsCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TransactionsTotalBytes != nil { + l = (*wrapperspb.UInt64Value)(m.TransactionsTotalBytes).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TransactionsTotalBytesCompressed != nil { + l = (*wrapperspb.UInt64Value)(m.TransactionsTotalBytesCompressed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TotalBytes != nil { + l = (*wrapperspb.UInt64Value)(m.TotalBytes).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TotalBytesCompressed != nil { + l = (*wrapperspb.UInt64Value)(m.TotalBytesCompressed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ExecutionValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ConsensusValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestDurationMs != nil { + l = (*wrapperspb.UInt64Value)(m.RequestDurationMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.RequestedAt != nil { + l = (*timestamppb.Timestamp)(m.RequestedAt).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalMevRelayValidatorRegistrationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Relay != nil { + l = m.Relay.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockSlot != nil { + l = m.WallclockSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.WallclockEpoch != nil { + l = m.WallclockEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ValidatorIndex != nil { + l = (*wrapperspb.UInt64Value)(m.ValidatorIndex).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalNodeRecordConsensusData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FinalizedEpoch != nil { + l = m.FinalizedEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HeadSlot != nil { + l = m.HeadSlot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HeadEpoch != nil { + l = m.HeadEpoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalConsensusEngineAPINewPayloadData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalConsensusEngineAPIGetBlobsData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_AdditionalEthV1BeaconBlobData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Slot != nil { + l = m.Slot.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Implementation) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Os) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ClockDrift != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ClockDrift)) + } + if m.Ethereum != nil { + l = m.Ethereum.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Labels) > 0 { + for k, v := range m.Labels { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + if vtmsg, ok := m.AdditionalData.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + if m.ModuleName != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.ModuleName)) + } + l = len(m.PresetName) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ClientMeta_EthV1EventsAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsAttestation != nil { + l = m.EthV1EventsAttestation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsHead) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsHead != nil { + l = m.EthV1EventsHead.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsBlock != nil { + l = m.EthV1EventsBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsVoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsVoluntaryExit != nil { + l = m.EthV1EventsVoluntaryExit.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsFinalizedCheckpoint) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsFinalizedCheckpoint != nil { + l = m.EthV1EventsFinalizedCheckpoint.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsChainReorg) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsChainReorg != nil { + l = m.EthV1EventsChainReorg.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsContributionAndProof) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsContributionAndProof != nil { + l = m.EthV1EventsContributionAndProof.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_MempoolTransaction) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MempoolTransaction != nil { + l = m.MempoolTransaction.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlock != nil { + l = m.EthV2BeaconBlock.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1DebugForkChoice) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1DebugForkChoice != nil { + l = m.EthV1DebugForkChoice.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1DebugForkChoiceReorg) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1DebugForkChoiceReorg != nil { + l = m.EthV1DebugForkChoiceReorg.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1BeaconCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconCommittee != nil { + l = m.EthV1BeaconCommittee.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1ValidatorAttestationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1ValidatorAttestationData != nil { + l = m.EthV1ValidatorAttestationData.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsAttestationV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsAttestationV2 != nil { + l = m.EthV1EventsAttestationV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsHeadV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsHeadV2 != nil { + l = m.EthV1EventsHeadV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsBlockV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsBlockV2 != nil { + l = m.EthV1EventsBlockV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsVoluntaryExitV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsVoluntaryExitV2 != nil { + l = m.EthV1EventsVoluntaryExitV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsFinalizedCheckpointV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsFinalizedCheckpointV2 != nil { + l = m.EthV1EventsFinalizedCheckpointV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsChainReorgV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsChainReorgV2 != nil { + l = m.EthV1EventsChainReorgV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsContributionAndProofV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsContributionAndProofV2 != nil { + l = m.EthV1EventsContributionAndProofV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_MempoolTransactionV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MempoolTransactionV2 != nil { + l = m.MempoolTransactionV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockV2 != nil { + l = m.EthV2BeaconBlockV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1DebugForkChoiceV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1DebugForkChoiceV2 != nil { + l = m.EthV1DebugForkChoiceV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1DebugForkChoiceReorgV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1DebugForkChoiceReorgV2 != nil { + l = m.EthV1DebugForkChoiceReorgV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockAttesterSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockAttesterSlashing != nil { + l = m.EthV2BeaconBlockAttesterSlashing.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockProposerSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockProposerSlashing != nil { + l = m.EthV2BeaconBlockProposerSlashing.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockVoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockVoluntaryExit != nil { + l = m.EthV2BeaconBlockVoluntaryExit.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockDeposit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockDeposit != nil { + l = m.EthV2BeaconBlockDeposit.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockBlsToExecutionChange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockBlsToExecutionChange != nil { + l = m.EthV2BeaconBlockBlsToExecutionChange.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockExecutionTransaction) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockExecutionTransaction != nil { + l = m.EthV2BeaconBlockExecutionTransaction.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockWithdrawal) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockWithdrawal != nil { + l = m.EthV2BeaconBlockWithdrawal.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsBlobSidecar != nil { + l = m.EthV1EventsBlobSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1BeaconBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconBlobSidecar != nil { + l = m.EthV1BeaconBlobSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_BeaconP2PAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BeaconP2PAttestation != nil { + l = m.BeaconP2PAttestation.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1ProposerDuty) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1ProposerDuty != nil { + l = m.EthV1ProposerDuty.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockElaboratedAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockElaboratedAttestation != nil { + l = m.EthV2BeaconBlockElaboratedAttestation.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceAddPeer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceAddPeer != nil { + l = m.Libp2PTraceAddPeer.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRemovePeer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRemovePeer != nil { + l = m.Libp2PTraceRemovePeer.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRecvRpc) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRecvRpc != nil { + l = m.Libp2PTraceRecvRpc.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceSendRpc) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceSendRpc != nil { + l = m.Libp2PTraceSendRpc.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceJoin) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceJoin != nil { + l = m.Libp2PTraceJoin.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceConnected) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceConnected != nil { + l = m.Libp2PTraceConnected.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceDisconnected) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceDisconnected != nil { + l = m.Libp2PTraceDisconnected.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceHandleMetadata) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceHandleMetadata != nil { + l = m.Libp2PTraceHandleMetadata.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceHandleStatus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceHandleStatus != nil { + l = m.Libp2PTraceHandleStatus.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceGossipsubBeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubBeaconBlock != nil { + l = m.Libp2PTraceGossipsubBeaconBlock.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceGossipsubBeaconAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubBeaconAttestation != nil { + l = m.Libp2PTraceGossipsubBeaconAttestation.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceGossipsubBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubBlobSidecar != nil { + l = m.Libp2PTraceGossipsubBlobSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1Validators) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1Validators != nil { + l = m.EthV1Validators.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_MevRelayBidTraceBuilderBlockSubmission) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MevRelayBidTraceBuilderBlockSubmission != nil { + l = m.MevRelayBidTraceBuilderBlockSubmission.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_MevRelayPayloadDelivered) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MevRelayPayloadDelivered != nil { + l = m.MevRelayPayloadDelivered.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV3ValidatorBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV3ValidatorBlock != nil { + l = m.EthV3ValidatorBlock.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_MevRelayValidatorRegistration) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MevRelayValidatorRegistration != nil { + l = m.MevRelayValidatorRegistration.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsBlockGossip) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsBlockGossip != nil { + l = m.EthV1EventsBlockGossip.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceDropRpc) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceDropRpc != nil { + l = m.Libp2PTraceDropRpc.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceLeave) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceLeave != nil { + l = m.Libp2PTraceLeave.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceGraft) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGraft != nil { + l = m.Libp2PTraceGraft.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTracePrune) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTracePrune != nil { + l = m.Libp2PTracePrune.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceDuplicateMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceDuplicateMessage != nil { + l = m.Libp2PTraceDuplicateMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceDeliverMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceDeliverMessage != nil { + l = m.Libp2PTraceDeliverMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTracePublishMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTracePublishMessage != nil { + l = m.Libp2PTracePublishMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRejectMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRejectMessage != nil { + l = m.Libp2PTraceRejectMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlIhave) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlIhave != nil { + l = m.Libp2PTraceRpcMetaControlIhave.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlIwant) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlIwant != nil { + l = m.Libp2PTraceRpcMetaControlIwant.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlIdontwant) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlIdontwant != nil { + l = m.Libp2PTraceRpcMetaControlIdontwant.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlGraft) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlGraft != nil { + l = m.Libp2PTraceRpcMetaControlGraft.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRpcMetaControlPrune) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlPrune != nil { + l = m.Libp2PTraceRpcMetaControlPrune.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRpcMetaSubscription) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaSubscription != nil { + l = m.Libp2PTraceRpcMetaSubscription.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRpcMetaMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaMessage != nil { + l = m.Libp2PTraceRpcMetaMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_NodeRecordConsensus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NodeRecordConsensus != nil { + l = m.NodeRecordConsensus.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceGossipsubAggregateAndProof) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubAggregateAndProof != nil { + l = m.Libp2PTraceGossipsubAggregateAndProof.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1EventsDataColumnSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsDataColumnSidecar != nil { + l = m.EthV1EventsDataColumnSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceGossipsubDataColumnSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubDataColumnSidecar != nil { + l = m.Libp2PTraceGossipsubDataColumnSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceSyntheticHeartbeat) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceSyntheticHeartbeat != nil { + l = m.Libp2PTraceSyntheticHeartbeat.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceRpcDataColumnCustodyProbe) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcDataColumnCustodyProbe != nil { + l = m.Libp2PTraceRpcDataColumnCustodyProbe.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_ConsensusEngineApiNewPayload) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ConsensusEngineApiNewPayload != nil { + l = m.ConsensusEngineApiNewPayload.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_ConsensusEngineApiGetBlobs) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ConsensusEngineApiGetBlobs != nil { + l = m.ConsensusEngineApiGetBlobs.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1BeaconBlob) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconBlob != nil { + l = m.EthV1BeaconBlob.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV1BeaconSyncCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconSyncCommittee != nil { + l = m.EthV1BeaconSyncCommittee.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_EthV2BeaconBlockSyncAggregate) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockSyncAggregate != nil { + l = m.EthV2BeaconBlockSyncAggregate.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ClientMeta_Libp2PTraceIdentify) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceIdentify != nil { + l = m.Libp2PTraceIdentify.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ServerMeta_Event) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ReceivedDateTime != nil { + l = (*timestamppb.Timestamp)(m.ReceivedDateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_Geo) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.City) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Country) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.CountryCode) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ContinentCode) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Latitude != 0 { + n += 9 + } + if m.Longitude != 0 { + n += 9 + } + if m.AutonomousSystemNumber != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.AutonomousSystemNumber)) + } + l = len(m.AutonomousSystemOrganization) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_Client) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.IP) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Geo != nil { + l = m.Geo.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Group) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.User) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_Peer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Geo != nil { + l = m.Geo.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_AdditionalBeaconP2PAttestationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Peer != nil { + l = m.Peer.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_AdditionalLibp2PTraceConnectedData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Peer != nil { + l = m.Peer.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_AdditionalLibp2PTraceDisconnectedData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Peer != nil { + l = m.Peer.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Peer != nil { + l = m.Peer.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_AdditionalLibp2PTraceIdentifyData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Peer != nil { + l = m.Peer.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_AdditionalNodeRecordConsensusData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Geo != nil { + l = m.Geo.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_AdditionalNodeRecordExecutionData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Geo != nil { + l = m.Geo.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Event != nil { + l = m.Event.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Client != nil { + l = m.Client.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if vtmsg, ok := m.AdditionalData.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *ServerMeta_BEACON_P2P_ATTESTATION) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BEACON_P2P_ATTESTATION != nil { + l = m.BEACON_P2P_ATTESTATION.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ServerMeta_LIBP2P_TRACE_CONNECTED) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LIBP2P_TRACE_CONNECTED != nil { + l = m.LIBP2P_TRACE_CONNECTED.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ServerMeta_LIBP2P_TRACE_DISCONNECTED) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LIBP2P_TRACE_DISCONNECTED != nil { + l = m.LIBP2P_TRACE_DISCONNECTED.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ServerMeta_NODE_RECORD_CONSENSUS) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NODE_RECORD_CONSENSUS != nil { + l = m.NODE_RECORD_CONSENSUS.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ServerMeta_NODE_RECORD_EXECUTION) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NODE_RECORD_EXECUTION != nil { + l = m.NODE_RECORD_EXECUTION.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ServerMeta_LIBP2P_TRACE_SYNTHETIC_HEARTBEAT) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LIBP2P_TRACE_SYNTHETIC_HEARTBEAT != nil { + l = m.LIBP2P_TRACE_SYNTHETIC_HEARTBEAT.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ServerMeta_LIBP2P_TRACE_IDENTIFY) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LIBP2P_TRACE_IDENTIFY != nil { + l = m.LIBP2P_TRACE_IDENTIFY.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Meta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Client != nil { + l = m.Client.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Server != nil { + l = m.Server.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Event) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Name != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Name)) + } + if m.DateTime != nil { + l = (*timestamppb.Timestamp)(m.DateTime).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionBlockMetrics_StateReads) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Accounts != nil { + l = (*wrapperspb.UInt64Value)(m.Accounts).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StorageSlots != nil { + l = (*wrapperspb.UInt64Value)(m.StorageSlots).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Code != nil { + l = (*wrapperspb.UInt64Value)(m.Code).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.CodeBytes != nil { + l = (*wrapperspb.UInt64Value)(m.CodeBytes).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionBlockMetrics_StateWrites) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Accounts != nil { + l = (*wrapperspb.UInt64Value)(m.Accounts).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AccountsDeleted != nil { + l = (*wrapperspb.UInt64Value)(m.AccountsDeleted).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StorageSlots != nil { + l = (*wrapperspb.UInt64Value)(m.StorageSlots).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StorageSlotsDeleted != nil { + l = (*wrapperspb.UInt64Value)(m.StorageSlotsDeleted).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Code != nil { + l = (*wrapperspb.UInt64Value)(m.Code).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.CodeBytes != nil { + l = (*wrapperspb.UInt64Value)(m.CodeBytes).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionBlockMetrics_CacheEntry) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Hits != nil { + l = (*wrapperspb.Int64Value)(m.Hits).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Misses != nil { + l = (*wrapperspb.Int64Value)(m.Misses).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HitRate != nil { + l = (*wrapperspb.DoubleValue)(m.HitRate).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionBlockMetrics_CodeCacheEntry) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Hits != nil { + l = (*wrapperspb.Int64Value)(m.Hits).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Misses != nil { + l = (*wrapperspb.Int64Value)(m.Misses).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HitRate != nil { + l = (*wrapperspb.DoubleValue)(m.HitRate).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.HitBytes != nil { + l = (*wrapperspb.Int64Value)(m.HitBytes).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MissBytes != nil { + l = (*wrapperspb.Int64Value)(m.MissBytes).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExecutionBlockMetrics) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Source) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.BlockNumber != nil { + l = (*wrapperspb.UInt64Value)(m.BlockNumber).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.GasUsed != nil { + l = (*wrapperspb.UInt64Value)(m.GasUsed).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TxCount != nil { + l = (*wrapperspb.UInt32Value)(m.TxCount).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ExecutionMs != nil { + l = (*wrapperspb.DoubleValue)(m.ExecutionMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StateReadMs != nil { + l = (*wrapperspb.DoubleValue)(m.StateReadMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StateHashMs != nil { + l = (*wrapperspb.DoubleValue)(m.StateHashMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.CommitMs != nil { + l = (*wrapperspb.DoubleValue)(m.CommitMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TotalMs != nil { + l = (*wrapperspb.DoubleValue)(m.TotalMs).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MgasPerSec != nil { + l = (*wrapperspb.DoubleValue)(m.MgasPerSec).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StateReads != nil { + l = m.StateReads.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StateWrites != nil { + l = m.StateWrites.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AccountCache != nil { + l = m.AccountCache.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StorageCache != nil { + l = m.StorageCache.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.CodeCache != nil { + l = m.CodeCache.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DecoratedEvent) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Event != nil { + l = m.Event.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Meta != nil { + l = m.Meta.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if vtmsg, ok := m.Data.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *DecoratedEvent_EthV1EventsAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsAttestation != nil { + l = m.EthV1EventsAttestation.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsBlock != nil { + l = m.EthV1EventsBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsChainReorg) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsChainReorg != nil { + l = m.EthV1EventsChainReorg.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsFinalizedCheckpoint) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsFinalizedCheckpoint != nil { + l = m.EthV1EventsFinalizedCheckpoint.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsHead) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsHead != nil { + l = m.EthV1EventsHead.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsVoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsVoluntaryExit != nil { + l = m.EthV1EventsVoluntaryExit.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsContributionAndProof) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsContributionAndProof != nil { + l = m.EthV1EventsContributionAndProof.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_MempoolTransaction) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.MempoolTransaction) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + return n +} +func (m *DecoratedEvent_EthV2BeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlock != nil { + l = m.EthV2BeaconBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1ForkChoice) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1ForkChoice != nil { + l = m.EthV1ForkChoice.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1ForkChoiceReorg) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1ForkChoiceReorg != nil { + l = m.EthV1ForkChoiceReorg.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1BeaconCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconCommittee != nil { + l = m.EthV1BeaconCommittee.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1ValidatorAttestationData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1ValidatorAttestationData != nil { + l = m.EthV1ValidatorAttestationData.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsAttestationV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsAttestationV2 != nil { + l = m.EthV1EventsAttestationV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsBlockV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsBlockV2 != nil { + l = m.EthV1EventsBlockV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsChainReorgV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsChainReorgV2 != nil { + l = m.EthV1EventsChainReorgV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsFinalizedCheckpointV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsFinalizedCheckpointV2 != nil { + l = m.EthV1EventsFinalizedCheckpointV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsHeadV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsHeadV2 != nil { + l = m.EthV1EventsHeadV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsVoluntaryExitV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsVoluntaryExitV2 != nil { + l = m.EthV1EventsVoluntaryExitV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsContributionAndProofV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsContributionAndProofV2 != nil { + l = m.EthV1EventsContributionAndProofV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_MempoolTransactionV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.MempoolTransactionV2) + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockV2 != nil { + l = m.EthV2BeaconBlockV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1ForkChoiceV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1ForkChoiceV2 != nil { + l = m.EthV1ForkChoiceV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1ForkChoiceReorgV2) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1ForkChoiceReorgV2 != nil { + l = m.EthV1ForkChoiceReorgV2.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockAttesterSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockAttesterSlashing != nil { + l = m.EthV2BeaconBlockAttesterSlashing.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockProposerSlashing) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockProposerSlashing != nil { + l = m.EthV2BeaconBlockProposerSlashing.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockVoluntaryExit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockVoluntaryExit != nil { + l = m.EthV2BeaconBlockVoluntaryExit.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockDeposit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockDeposit != nil { + l = m.EthV2BeaconBlockDeposit.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockBlsToExecutionChange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockBlsToExecutionChange != nil { + l = m.EthV2BeaconBlockBlsToExecutionChange.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockExecutionTransaction) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockExecutionTransaction != nil { + l = m.EthV2BeaconBlockExecutionTransaction.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockWithdrawal) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockWithdrawal != nil { + l = m.EthV2BeaconBlockWithdrawal.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsBlobSidecar != nil { + l = m.EthV1EventsBlobSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1BeaconBlockBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconBlockBlobSidecar != nil { + l = m.EthV1BeaconBlockBlobSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_BeaconP2PAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BeaconP2PAttestation != nil { + l = m.BeaconP2PAttestation.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1ProposerDuty) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1ProposerDuty != nil { + l = m.EthV1ProposerDuty.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockElaboratedAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockElaboratedAttestation != nil { + l = m.EthV2BeaconBlockElaboratedAttestation.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceAddPeer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceAddPeer != nil { + l = m.Libp2PTraceAddPeer.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRemovePeer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRemovePeer != nil { + l = m.Libp2PTraceRemovePeer.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRecvRpc) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRecvRpc != nil { + l = m.Libp2PTraceRecvRpc.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceSendRpc) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceSendRpc != nil { + l = m.Libp2PTraceSendRpc.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceJoin) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceJoin != nil { + l = m.Libp2PTraceJoin.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceConnected) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceConnected != nil { + l = m.Libp2PTraceConnected.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceDisconnected) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceDisconnected != nil { + l = m.Libp2PTraceDisconnected.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceHandleMetadata) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceHandleMetadata != nil { + l = m.Libp2PTraceHandleMetadata.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceHandleStatus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceHandleStatus != nil { + l = m.Libp2PTraceHandleStatus.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceGossipsubBeaconBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubBeaconBlock != nil { + l = m.Libp2PTraceGossipsubBeaconBlock.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceGossipsubBeaconAttestation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubBeaconAttestation != nil { + l = m.Libp2PTraceGossipsubBeaconAttestation.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceGossipsubBlobSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubBlobSidecar != nil { + l = m.Libp2PTraceGossipsubBlobSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1Validators) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1Validators != nil { + l = m.EthV1Validators.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_MevRelayBidTraceBuilderBlockSubmission) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MevRelayBidTraceBuilderBlockSubmission != nil { + l = m.MevRelayBidTraceBuilderBlockSubmission.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_MevRelayPayloadDelivered) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MevRelayPayloadDelivered != nil { + l = m.MevRelayPayloadDelivered.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV3ValidatorBlock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV3ValidatorBlock != nil { + l = m.EthV3ValidatorBlock.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_MevRelayValidatorRegistration) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MevRelayValidatorRegistration != nil { + l = m.MevRelayValidatorRegistration.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsBlockGossip) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsBlockGossip != nil { + l = m.EthV1EventsBlockGossip.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceDropRpc) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceDropRpc != nil { + l = m.Libp2PTraceDropRpc.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceLeave) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceLeave != nil { + l = m.Libp2PTraceLeave.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceGraft) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGraft != nil { + l = m.Libp2PTraceGraft.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTracePrune) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTracePrune != nil { + l = m.Libp2PTracePrune.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceDuplicateMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceDuplicateMessage != nil { + l = m.Libp2PTraceDuplicateMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceDeliverMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceDeliverMessage != nil { + l = m.Libp2PTraceDeliverMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTracePublishMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTracePublishMessage != nil { + l = m.Libp2PTracePublishMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRejectMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRejectMessage != nil { + l = m.Libp2PTraceRejectMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIhave) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlIhave != nil { + l = m.Libp2PTraceRpcMetaControlIhave.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIwant) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlIwant != nil { + l = m.Libp2PTraceRpcMetaControlIwant.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlIdontwant) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlIdontwant != nil { + l = m.Libp2PTraceRpcMetaControlIdontwant.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlGraft) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlGraft != nil { + l = m.Libp2PTraceRpcMetaControlGraft.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaControlPrune) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaControlPrune != nil { + l = m.Libp2PTraceRpcMetaControlPrune.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaSubscription) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaSubscription != nil { + l = m.Libp2PTraceRpcMetaSubscription.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRpcMetaMessage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcMetaMessage != nil { + l = m.Libp2PTraceRpcMetaMessage.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_NodeRecordConsensus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NodeRecordConsensus != nil { + l = m.NodeRecordConsensus.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_NodeRecordExecution) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NodeRecordExecution != nil { + l = m.NodeRecordExecution.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceGossipsubAggregateAndProof) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubAggregateAndProof != nil { + l = m.Libp2PTraceGossipsubAggregateAndProof.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1EventsDataColumnSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1EventsDataColumnSidecar != nil { + l = m.EthV1EventsDataColumnSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceGossipsubDataColumnSidecar) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceGossipsubDataColumnSidecar != nil { + l = m.Libp2PTraceGossipsubDataColumnSidecar.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceSyntheticHeartbeat) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceSyntheticHeartbeat != nil { + l = m.Libp2PTraceSyntheticHeartbeat.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceIdentify) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceIdentify != nil { + l = m.Libp2PTraceIdentify.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_Libp2PTraceRpcDataColumnCustodyProbe) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Libp2PTraceRpcDataColumnCustodyProbe != nil { + l = m.Libp2PTraceRpcDataColumnCustodyProbe.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_ExecutionStateSize) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ExecutionStateSize != nil { + l = m.ExecutionStateSize.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_ConsensusEngineApiNewPayload) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ConsensusEngineApiNewPayload != nil { + l = m.ConsensusEngineApiNewPayload.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_ConsensusEngineApiGetBlobs) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ConsensusEngineApiGetBlobs != nil { + l = m.ConsensusEngineApiGetBlobs.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_ExecutionEngineNewPayload) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ExecutionEngineNewPayload != nil { + l = m.ExecutionEngineNewPayload.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_ExecutionEngineGetBlobs) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ExecutionEngineGetBlobs != nil { + l = m.ExecutionEngineGetBlobs.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1BeaconBlob) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconBlob != nil { + l = m.EthV1BeaconBlob.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV1BeaconSyncCommittee) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV1BeaconSyncCommittee != nil { + l = m.EthV1BeaconSyncCommittee.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_EthV2BeaconBlockSyncAggregate) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EthV2BeaconBlockSyncAggregate != nil { + l = m.EthV2BeaconBlockSyncAggregate.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DecoratedEvent_ExecutionBlockMetrics) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ExecutionBlockMetrics != nil { + l = m.ExecutionBlockMetrics.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *CreateEventsRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateEventsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Events) == cap(m.Events) { + m.Events = append(m.Events, &DecoratedEvent{}) + } else { + m.Events = m.Events[:len(m.Events)+1] + if m.Events[len(m.Events)-1] == nil { + m.Events[len(m.Events)-1] = &DecoratedEvent{} + } + } + if err := m.Events[len(m.Events)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CreateEventsResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CreateEventsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CreateEventsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EventsIngested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EventsIngested == nil { + m.EventsIngested = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.EventsIngested).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Epoch) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Epoch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Epoch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + m.Number = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Number |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartDateTime == nil { + m.StartDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.StartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EpochV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EpochV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EpochV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Number == nil { + m.Number = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Number).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartDateTime == nil { + m.StartDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.StartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Slot) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Slot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Slot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + m.Number = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Number |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartDateTime == nil { + m.StartDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.StartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SlotV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SlotV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SlotV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Number == nil { + m.Number = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Number).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartDateTime == nil { + m.StartDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.StartDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ForkID) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ForkID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ForkID: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Next", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Next = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Propagation) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Propagation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Propagation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SlotStartDiff", wireType) + } + m.SlotStartDiff = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SlotStartDiff |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PropagationV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PropagationV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PropagationV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SlotStartDiff", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SlotStartDiff == nil { + m.SlotStartDiff = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SlotStartDiff).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AttestingValidator) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AttestingValidator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AttestingValidator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CommitteeIndex", wireType) + } + m.CommitteeIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CommitteeIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AttestingValidatorV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AttestingValidatorV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AttestingValidatorV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommitteeIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CommitteeIndex == nil { + m.CommitteeIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.CommitteeIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Index == nil { + m.Index = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Index).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DebugForkChoiceReorg) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DebugForkChoiceReorg: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DebugForkChoiceReorg: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Before", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Before == nil { + m.Before = v1.ForkChoiceFromVTPool() + } + if err := m.Before.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field After", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.After == nil { + m.After = v1.ForkChoiceFromVTPool() + } + if err := m.After.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Event == nil { + m.Event = v1.EventChainReorgFromVTPool() + } + if err := m.Event.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DebugForkChoiceReorgV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DebugForkChoiceReorgV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DebugForkChoiceReorgV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Before", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Before == nil { + m.Before = v1.ForkChoiceV2FromVTPool() + } + if err := m.Before.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field After", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.After == nil { + m.After = v1.ForkChoiceV2FromVTPool() + } + if err := m.After.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Event == nil { + m.Event = v1.EventChainReorgV2FromVTPool() + } + if err := m.Event.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Validators) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Validators: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Validators: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.Validators) == cap(m.Validators) { + m.Validators = append(m.Validators, &v1.Validator{}) + } else { + m.Validators = m.Validators[:len(m.Validators)+1] + if m.Validators[len(m.Validators)-1] == nil { + m.Validators[len(m.Validators)-1] = &v1.Validator{} + } + } + if err := m.Validators[len(m.Validators)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyncCommitteeData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyncCommitteeData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncCommitteeData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncCommittee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncCommittee == nil { + m.SyncCommittee = v1.SyncCommitteeFromVTPool() + } + if err := m.SyncCommittee.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyncAggregateData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyncAggregateData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncAggregateData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncCommitteeBits", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SyncCommitteeBits = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncCommitteeSignature", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SyncCommitteeSignature = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorsParticipated", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ValidatorsParticipated) == cap(m.ValidatorsParticipated) { + m.ValidatorsParticipated = append(m.ValidatorsParticipated, &wrapperspb1.UInt64Value{}) + } else { + m.ValidatorsParticipated = m.ValidatorsParticipated[:len(m.ValidatorsParticipated)+1] + if m.ValidatorsParticipated[len(m.ValidatorsParticipated)-1] == nil { + m.ValidatorsParticipated[len(m.ValidatorsParticipated)-1] = &wrapperspb1.UInt64Value{} + } + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorsParticipated[len(m.ValidatorsParticipated)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorsMissed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ValidatorsMissed) == cap(m.ValidatorsMissed) { + m.ValidatorsMissed = append(m.ValidatorsMissed, &wrapperspb1.UInt64Value{}) + } else { + m.ValidatorsMissed = m.ValidatorsMissed[:len(m.ValidatorsMissed)+1] + if m.ValidatorsMissed[len(m.ValidatorsMissed)-1] == nil { + m.ValidatorsMissed[len(m.ValidatorsMissed)-1] = &wrapperspb1.UInt64Value{} + } + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorsMissed[len(m.ValidatorsMissed)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParticipationCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ParticipationCount == nil { + m.ParticipationCount = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ParticipationCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlockIdentifier) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlockIdentifier: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockIdentifier: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Root = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionStateSize) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionStateSize: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionStateSize: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AccountBytes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AccountBytes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AccountTrienodeBytes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AccountTrienodeBytes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AccountTrienodes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AccountTrienodes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Accounts", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Accounts = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockNumber = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractCodeBytes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractCodeBytes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractCodes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractCodes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageBytes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StorageBytes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageTrienodeBytes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StorageTrienodeBytes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageTrienodes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StorageTrienodes = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Storages", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Storages = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConsensusEngineAPINewPayload) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConsensusEngineAPINewPayload: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConsensusEngineAPINewPayload: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAt == nil { + m.RequestedAt = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.RequestedAt).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DurationMs == nil { + m.DurationMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.DurationMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentBlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentBlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProposerIndex == nil { + m.ProposerIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ProposerIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TxCount == nil { + m.TxCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.TxCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlobCount == nil { + m.BlobCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.BlobCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestValidHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LatestValidHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidationError", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidationError = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MethodVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MethodVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConsensusEngineAPIGetBlobs) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConsensusEngineAPIGetBlobs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConsensusEngineAPIGetBlobs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAt == nil { + m.RequestedAt = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.RequestedAt).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DurationMs == nil { + m.DurationMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.DurationMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Slot).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentBlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentBlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedCount == nil { + m.RequestedCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.RequestedCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionedHashes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionedHashes = append(m.VersionedHashes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReturnedCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReturnedCount == nil { + m.ReturnedCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ReturnedCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ErrorMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MethodVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MethodVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionEngineNewPayload) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionEngineNewPayload: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionEngineNewPayload: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + m.Source = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Source |= EngineSource(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAt == nil { + m.RequestedAt = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.RequestedAt).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DurationMs == nil { + m.DurationMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.DurationMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasLimit == nil { + m.GasLimit = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasLimit).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TxCount == nil { + m.TxCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.TxCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlobCount == nil { + m.BlobCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.BlobCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestValidHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LatestValidHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidationError", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidationError = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MethodVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MethodVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionEngineGetBlobs) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionEngineGetBlobs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionEngineGetBlobs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + m.Source = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Source |= EngineSource(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAt == nil { + m.RequestedAt = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.RequestedAt).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DurationMs == nil { + m.DurationMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.DurationMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedCount == nil { + m.RequestedCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.RequestedCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionedHashes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionedHashes = append(m.VersionedHashes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReturnedCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReturnedCount == nil { + m.ReturnedCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.ReturnedCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ErrorMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MethodVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MethodVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReturnedBlobIndexes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if len(m.ReturnedBlobIndexes) == cap(m.ReturnedBlobIndexes) { + m.ReturnedBlobIndexes = append(m.ReturnedBlobIndexes, &wrapperspb1.UInt32Value{}) + } else { + m.ReturnedBlobIndexes = m.ReturnedBlobIndexes[:len(m.ReturnedBlobIndexes)+1] + if m.ReturnedBlobIndexes[len(m.ReturnedBlobIndexes)-1] == nil { + m.ReturnedBlobIndexes[len(m.ReturnedBlobIndexes)-1] = &wrapperspb1.UInt32Value{} + } + } + if err := (*wrapperspb.UInt32Value)(m.ReturnedBlobIndexes[len(m.ReturnedBlobIndexes)-1]).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_Ethereum_Network) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_Ethereum_Network: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_Ethereum_Network: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_Ethereum_Execution) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_Ethereum_Execution: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_Ethereum_Execution: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForkId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ForkId == nil { + m.ForkId = ForkIDFromVTPool() + } + if err := m.ForkId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Implementation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Implementation = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionMajor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionMajor = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionMinor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionMinor = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionPatch", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionPatch = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_Ethereum_Consensus) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_Ethereum_Consensus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_Ethereum_Consensus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Implementation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Implementation = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_Ethereum) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_Ethereum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_Ethereum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Network == nil { + m.Network = ClientMeta_Ethereum_NetworkFromVTPool() + } + if err := m.Network.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Execution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Execution == nil { + m.Execution = ClientMeta_Ethereum_ExecutionFromVTPool() + } + if err := m.Execution.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Consensus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Consensus == nil { + m.Consensus = ClientMeta_Ethereum_ConsensusFromVTPool() + } + if err := m.Consensus.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1AttestationSourceData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1AttestationSourceData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1AttestationSourceData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1AttestationSourceV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1AttestationSourceV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1AttestationSourceV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1AttestationTargetData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1AttestationTargetData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1AttestationTargetData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1AttestationTargetV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1AttestationTargetV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1AttestationTargetV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsAttestationData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsAttestationData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsAttestationData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = ClientMeta_AdditionalEthV1AttestationSourceDataFromVTPool() + } + if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Target == nil { + m.Target = ClientMeta_AdditionalEthV1AttestationTargetDataFromVTPool() + } + if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotFromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationFromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttestingValidator", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AttestingValidator == nil { + m.AttestingValidator = AttestingValidatorFromVTPool() + } + if err := m.AttestingValidator.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsAttestationV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsAttestationV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsAttestationV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = ClientMeta_AdditionalEthV1AttestationSourceV2DataFromVTPool() + } + if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Target == nil { + m.Target = ClientMeta_AdditionalEthV1AttestationTargetV2DataFromVTPool() + } + if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttestingValidator", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AttestingValidator == nil { + m.AttestingValidator = AttestingValidatorV2FromVTPool() + } + if err := m.AttestingValidator.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsHeadData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsHeadData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsHeadData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotFromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationFromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsHeadV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsHeadV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsHeadV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsBlockData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsBlockData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsBlockData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotFromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationFromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsBlockV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsBlockV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsBlockV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsBlockGossipData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsBlockGossipData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsBlockGossipData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsVoluntaryExitData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsVoluntaryExitData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsVoluntaryExitV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsFinalizedCheckpointData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsChainReorgData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsChainReorgData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsChainReorgData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotFromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationFromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsChainReorgV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsChainReorgV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsChainReorgV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsContributionAndProofContributionData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotFromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationFromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsContributionAndProofData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsContributionAndProofData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contribution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Contribution == nil { + m.Contribution = ClientMeta_AdditionalEthV1EventsContributionAndProofContributionDataFromVTPool() + } + if err := m.Contribution.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsContributionAndProofV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Contribution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Contribution == nil { + m.Contribution = ClientMeta_AdditionalEthV1EventsContributionAndProofContributionV2DataFromVTPool() + } + if err := m.Contribution.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_ForkChoiceSnapshot) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_ForkChoiceSnapshot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_ForkChoiceSnapshot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestEpoch == nil { + m.RequestEpoch = EpochFromVTPool() + } + if err := m.RequestEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestSlot == nil { + m.RequestSlot = SlotFromVTPool() + } + if err := m.RequestSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAtSlotStartDiffMs", wireType) + } + m.RequestedAtSlotStartDiffMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestedAtSlotStartDiffMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestDurationMs", wireType) + } + m.RequestDurationMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestDurationMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_ForkChoiceSnapshotV2) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_ForkChoiceSnapshotV2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_ForkChoiceSnapshotV2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestEpoch == nil { + m.RequestEpoch = EpochV2FromVTPool() + } + if err := m.RequestEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestSlot == nil { + m.RequestSlot = SlotV2FromVTPool() + } + if err := m.RequestSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAtSlotStartDiffMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAtSlotStartDiffMs == nil { + m.RequestedAtSlotStartDiffMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.RequestedAtSlotStartDiffMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestDurationMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestDurationMs == nil { + m.RequestDurationMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.RequestDurationMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1DebugForkChoiceData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1DebugForkChoiceData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Snapshot == nil { + m.Snapshot = ClientMeta_ForkChoiceSnapshotFromVTPool() + } + if err := m.Snapshot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1DebugForkChoiceV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1DebugForkChoiceV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Snapshot == nil { + m.Snapshot = ClientMeta_ForkChoiceSnapshotV2FromVTPool() + } + if err := m.Snapshot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1DebugForkChoiceReOrgData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Before", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Before == nil { + m.Before = ClientMeta_ForkChoiceSnapshotFromVTPool() + } + if err := m.Before.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field After", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.After == nil { + m.After = ClientMeta_ForkChoiceSnapshotFromVTPool() + } + if err := m.After.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Before", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Before == nil { + m.Before = ClientMeta_ForkChoiceSnapshotV2FromVTPool() + } + if err := m.Before.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field After", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.After == nil { + m.After = ClientMeta_ForkChoiceSnapshotV2FromVTPool() + } + if err := m.After.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1BeaconCommitteeData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1BeaconCommitteeData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1BeaconCommitteeData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1BeaconSyncCommitteeData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1BeaconSyncCommitteeData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1BeaconSyncCommitteeData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncCommitteePeriod", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncCommitteePeriod == nil { + m.SyncCommitteePeriod = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SyncCommitteePeriod).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncCommitteePeriod", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncCommitteePeriod == nil { + m.SyncCommitteePeriod = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.SyncCommitteePeriod).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalMempoolTransactionData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalMempoolTransactionData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalMempoolTransactionData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.From = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.To = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + m.Nonce = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Nonce |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasPrice", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GasPrice = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Gas", wireType) + } + m.Gas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Gas |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Size", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Size = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CallDataSize", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CallDataSize = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalMempoolTransactionV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalMempoolTransactionV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalMempoolTransactionV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.From = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.To = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nonce == nil { + m.Nonce = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Nonce).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasPrice", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GasPrice = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Gas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Gas == nil { + m.Gas = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Gas).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Size", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Size = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CallDataSize", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CallDataSize = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Type == nil { + m.Type = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Type).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasTipCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GasTipCap = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasFeeCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GasFeeCap = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobGas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlobGas == nil { + m.BlobGas = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlobGas).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobGasFeeCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobGasFeeCap = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobHashes", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobHashes = append(m.BlobHashes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobSidecarsSize", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobSidecarsSize = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobSidecarsEmptySize", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobSidecarsEmptySize = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochFromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotFromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsCount", wireType) + } + m.TransactionsCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TransactionsCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsTotalBytes", wireType) + } + m.TransactionsTotalBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TransactionsTotalBytes |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockV2Data) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockV2Data: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockV2Data: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockRoot = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TransactionsCount == nil { + m.TransactionsCount = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TransactionsCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsTotalBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TransactionsTotalBytes == nil { + m.TransactionsTotalBytes = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TransactionsTotalBytes).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsTotalBytesCompressed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TransactionsTotalBytesCompressed == nil { + m.TransactionsTotalBytesCompressed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TransactionsTotalBytesCompressed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TotalBytes == nil { + m.TotalBytes = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TotalBytes).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytesCompressed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TotalBytesCompressed == nil { + m.TotalBytesCompressed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TotalBytesCompressed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedWhenRequested", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.FinalizedWhenRequested = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockDepositData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockDepositData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockDepositData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionInBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionInBlock == nil { + m.PositionInBlock = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.PositionInBlock).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Size", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Size = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CallDataSize", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CallDataSize = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobSidecarsSize", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobSidecarsSize = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlobSidecarsEmptySize", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlobSidecarsEmptySize = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockWithdrawalData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AttestationDataSnapshot) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AttestationDataSnapshot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AttestationDataSnapshot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAtSlotStartDiffMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAtSlotStartDiffMs == nil { + m.RequestedAtSlotStartDiffMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.RequestedAtSlotStartDiffMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestDurationMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestDurationMs == nil { + m.RequestDurationMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.RequestDurationMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1ValidatorAttestationDataData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1ValidatorAttestationDataData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1ValidatorAttestationDataData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = ClientMeta_AdditionalEthV1AttestationSourceV2DataFromVTPool() + } + if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Target == nil { + m.Target = ClientMeta_AdditionalEthV1AttestationTargetV2DataFromVTPool() + } + if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Snapshot == nil { + m.Snapshot = ClientMeta_AttestationDataSnapshotFromVTPool() + } + if err := m.Snapshot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsBlobSidecarData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsBlobSidecarData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsBlobSidecarData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1EventsDataColumnSidecarData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsDataColumnSidecarData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1EventsDataColumnSidecarData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1BeaconBlobSidecarData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1BeaconBlobSidecarData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1BeaconBlobSidecarData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DataSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DataSize == nil { + m.DataSize = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.DataSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionedHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionedHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DataEmptySize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DataEmptySize == nil { + m.DataEmptySize = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.DataEmptySize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalBeaconP2PAttestationData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalBeaconP2PAttestationData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalBeaconP2PAttestationData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = ClientMeta_AdditionalEthV1AttestationSourceV2DataFromVTPool() + } + if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Target == nil { + m.Target = ClientMeta_AdditionalEthV1AttestationTargetV2DataFromVTPool() + } + if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttestingValidator", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AttestingValidator == nil { + m.AttestingValidator = AttestingValidatorV2FromVTPool() + } + if err := m.AttestingValidator.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Peer == nil { + m.Peer = libp2p.PeerFromVTPool() + } + if err := m.Peer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Subnet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Subnet == nil { + m.Subnet = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.Subnet).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validated", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Validated == nil { + m.Validated = &wrapperspb1.BoolValue{} + } + if err := (*wrapperspb.BoolValue)(m.Validated).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1ProposerDutyData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1ProposerDutyData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1ProposerDutyData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = BlockIdentifierFromVTPool() + } + if err := m.Block.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PositionInBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PositionInBlock == nil { + m.PositionInBlock = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.PositionInBlock).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = ClientMeta_AdditionalEthV1AttestationSourceV2DataFromVTPool() + } + if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Target == nil { + m.Target = ClientMeta_AdditionalEthV1AttestationTargetV2DataFromVTPool() + } + if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceAddPeerData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceAddPeerData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceAddPeerData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRemovePeerData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRemovePeerData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRemovePeerData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRecvRPCData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRecvRPCData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRecvRPCData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceSendRPCData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceSendRPCData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceSendRPCData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceDropRPCData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceDropRPCData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceDropRPCData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceJoinData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceJoinData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceJoinData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceLeaveData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceLeaveData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceLeaveData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceGraftData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGraftData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGraftData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTracePruneData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTracePruneData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTracePruneData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceDuplicateMessageData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceDuplicateMessageData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceDuplicateMessageData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceDeliverMessageData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceDeliverMessageData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceDeliverMessageData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTracePublishMessageData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTracePublishMessageData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTracePublishMessageData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRejectMessageData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRejectMessageData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRejectMessageData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceConnectedData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceConnectedData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceConnectedData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceDisconnectedData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceDisconnectedData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceDisconnectedData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceHandleMetadataData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceHandleMetadataData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceHandleMetadataData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceHandleStatusData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceHandleStatusData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceHandleStatusData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceIdentifyData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceIdentifyData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceIdentifyData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceRPCMetaMessageData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageSize == nil { + m.MessageSize = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MessageSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Source == nil { + m.Source = ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationSourceDataFromVTPool() + } + if err := m.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Target == nil { + m.Target = ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationTargetDataFromVTPool() + } + if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttestingValidator", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AttestingValidator == nil { + m.AttestingValidator = AttestingValidatorV2FromVTPool() + } + if err := m.AttestingValidator.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageSize == nil { + m.MessageSize = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MessageSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AggregatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AggregatorIndex == nil { + m.AggregatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.AggregatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageSize == nil { + m.MessageSize = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MessageSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageSize == nil { + m.MessageSize = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MessageSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Propagation == nil { + m.Propagation = PropagationV2FromVTPool() + } + if err := m.Propagation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Metadata == nil { + m.Metadata = libp2p.TraceEventMetadataFromVTPool() + } + if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Topic == nil { + m.Topic = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.Topic).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageSize == nil { + m.MessageSize = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.MessageSize).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MessageId == nil { + m.MessageId = &wrapperspb1.StringValue{} + } + if err := (*wrapperspb.StringValue)(m.MessageId).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1ValidatorsData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1ValidatorsData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1ValidatorsData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Relay", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Relay == nil { + m.Relay = mevrelay.RelayFromVTPool() + } + if err := m.Relay.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAtSlotTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAtSlotTime == nil { + m.RequestedAtSlotTime = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.RequestedAtSlotTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseAtSlotTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ResponseAtSlotTime == nil { + m.ResponseAtSlotTime = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ResponseAtSlotTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalMevRelayPayloadDeliveredData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalMevRelayPayloadDeliveredData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalMevRelayPayloadDeliveredData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Relay", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Relay == nil { + m.Relay = mevrelay.RelayFromVTPool() + } + if err := m.Relay.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAtSlotTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAtSlotTime == nil { + m.RequestedAtSlotTime = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.RequestedAtSlotTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseAtSlotTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ResponseAtSlotTime == nil { + m.ResponseAtSlotTime = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ResponseAtSlotTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV3ValidatorBlockData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV3ValidatorBlockData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV3ValidatorBlockData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TransactionsCount == nil { + m.TransactionsCount = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TransactionsCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsTotalBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TransactionsTotalBytes == nil { + m.TransactionsTotalBytes = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TransactionsTotalBytes).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransactionsTotalBytesCompressed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TransactionsTotalBytesCompressed == nil { + m.TransactionsTotalBytesCompressed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TransactionsTotalBytesCompressed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TotalBytes == nil { + m.TotalBytes = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TotalBytes).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytesCompressed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TotalBytesCompressed == nil { + m.TotalBytesCompressed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.TotalBytesCompressed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExecutionValue = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsensusValue = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestDurationMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestDurationMs == nil { + m.RequestDurationMs = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.RequestDurationMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RequestedAt == nil { + m.RequestedAt = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.RequestedAt).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalMevRelayValidatorRegistrationData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalMevRelayValidatorRegistrationData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalMevRelayValidatorRegistrationData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Relay", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Relay == nil { + m.Relay = mevrelay.RelayFromVTPool() + } + if err := m.Relay.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockSlot == nil { + m.WallclockSlot = SlotV2FromVTPool() + } + if err := m.WallclockSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WallclockEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WallclockEpoch == nil { + m.WallclockEpoch = EpochV2FromVTPool() + } + if err := m.WallclockEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorIndex == nil { + m.ValidatorIndex = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.ValidatorIndex).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalNodeRecordConsensusData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalNodeRecordConsensusData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalNodeRecordConsensusData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinalizedEpoch == nil { + m.FinalizedEpoch = EpochV2FromVTPool() + } + if err := m.FinalizedEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadSlot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeadSlot == nil { + m.HeadSlot = SlotV2FromVTPool() + } + if err := m.HeadSlot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HeadEpoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HeadEpoch == nil { + m.HeadEpoch = EpochV2FromVTPool() + } + if err := m.HeadEpoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalConsensusEngineAPINewPayloadData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalConsensusEngineAPINewPayloadData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalConsensusEngineAPINewPayloadData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalConsensusEngineAPIGetBlobsData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalConsensusEngineAPIGetBlobsData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalConsensusEngineAPIGetBlobsData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta_AdditionalEthV1BeaconBlobData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1BeaconBlobData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta_AdditionalEthV1BeaconBlobData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = EpochV2FromVTPool() + } + if err := m.Epoch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Slot == nil { + m.Slot = SlotV2FromVTPool() + } + if err := m.Slot.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClientMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClientMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Implementation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Implementation = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Os", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Os = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClockDrift", wireType) + } + m.ClockDrift = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ClockDrift |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ethereum", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Ethereum == nil { + m.Ethereum = ClientMeta_EthereumFromVTPool() + } + if err := m.Ethereum.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Labels == nil { + m.Labels = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Labels[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsAttestation); ok { + if err := oneof.EthV1EventsAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsAttestationDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsAttestation{EthV1EventsAttestation: v} + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsHead", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsHead); ok { + if err := oneof.EthV1EventsHead.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsHeadDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsHead{EthV1EventsHead: v} + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsBlock); ok { + if err := oneof.EthV1EventsBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsBlockDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsBlock{EthV1EventsBlock: v} + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsVoluntaryExit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsVoluntaryExit); ok { + if err := oneof.EthV1EventsVoluntaryExit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsVoluntaryExitDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsVoluntaryExit{EthV1EventsVoluntaryExit: v} + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsFinalizedCheckpoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsFinalizedCheckpoint); ok { + if err := oneof.EthV1EventsFinalizedCheckpoint.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsFinalizedCheckpointDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsFinalizedCheckpoint{EthV1EventsFinalizedCheckpoint: v} + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsChainReorg", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsChainReorg); ok { + if err := oneof.EthV1EventsChainReorg.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsChainReorgDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsChainReorg{EthV1EventsChainReorg: v} + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsContributionAndProof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsContributionAndProof); ok { + if err := oneof.EthV1EventsContributionAndProof.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsContributionAndProofDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsContributionAndProof{EthV1EventsContributionAndProof: v} + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MempoolTransaction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MempoolTransaction); ok { + if err := oneof.MempoolTransaction.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalMempoolTransactionDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_MempoolTransaction{MempoolTransaction: v} + } + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlock); ok { + if err := oneof.EthV2BeaconBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlock{EthV2BeaconBlock: v} + } + iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1DebugForkChoice", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1DebugForkChoice); ok { + if err := oneof.EthV1DebugForkChoice.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1DebugForkChoiceDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1DebugForkChoice{EthV1DebugForkChoice: v} + } + iNdEx = postIndex + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1DebugForkChoiceReorg", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1DebugForkChoiceReorg); ok { + if err := oneof.EthV1DebugForkChoiceReorg.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1DebugForkChoiceReOrgDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1DebugForkChoiceReorg{EthV1DebugForkChoiceReorg: v} + } + iNdEx = postIndex + case 21: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconCommittee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1BeaconCommittee); ok { + if err := oneof.EthV1BeaconCommittee.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1BeaconCommitteeDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1BeaconCommittee{EthV1BeaconCommittee: v} + } + iNdEx = postIndex + case 22: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1ValidatorAttestationData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1ValidatorAttestationData); ok { + if err := oneof.EthV1ValidatorAttestationData.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1ValidatorAttestationDataDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1ValidatorAttestationData{EthV1ValidatorAttestationData: v} + } + iNdEx = postIndex + case 24: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsAttestationV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsAttestationV2); ok { + if err := oneof.EthV1EventsAttestationV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsAttestationV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsAttestationV2{EthV1EventsAttestationV2: v} + } + iNdEx = postIndex + case 25: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsHeadV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsHeadV2); ok { + if err := oneof.EthV1EventsHeadV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsHeadV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsHeadV2{EthV1EventsHeadV2: v} + } + iNdEx = postIndex + case 26: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsBlockV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsBlockV2); ok { + if err := oneof.EthV1EventsBlockV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsBlockV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsBlockV2{EthV1EventsBlockV2: v} + } + iNdEx = postIndex + case 27: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsVoluntaryExitV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsVoluntaryExitV2); ok { + if err := oneof.EthV1EventsVoluntaryExitV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsVoluntaryExitV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsVoluntaryExitV2{EthV1EventsVoluntaryExitV2: v} + } + iNdEx = postIndex + case 28: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsFinalizedCheckpointV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsFinalizedCheckpointV2); ok { + if err := oneof.EthV1EventsFinalizedCheckpointV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsFinalizedCheckpointV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsFinalizedCheckpointV2{EthV1EventsFinalizedCheckpointV2: v} + } + iNdEx = postIndex + case 29: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsChainReorgV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsChainReorgV2); ok { + if err := oneof.EthV1EventsChainReorgV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsChainReorgV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsChainReorgV2{EthV1EventsChainReorgV2: v} + } + iNdEx = postIndex + case 30: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsContributionAndProofV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsContributionAndProofV2); ok { + if err := oneof.EthV1EventsContributionAndProofV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsContributionAndProofV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsContributionAndProofV2{EthV1EventsContributionAndProofV2: v} + } + iNdEx = postIndex + case 31: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MempoolTransactionV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MempoolTransactionV2); ok { + if err := oneof.MempoolTransactionV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalMempoolTransactionV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_MempoolTransactionV2{MempoolTransactionV2: v} + } + iNdEx = postIndex + case 32: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockV2); ok { + if err := oneof.EthV2BeaconBlockV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockV2{EthV2BeaconBlockV2: v} + } + iNdEx = postIndex + case 33: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1DebugForkChoiceV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1DebugForkChoiceV2); ok { + if err := oneof.EthV1DebugForkChoiceV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1DebugForkChoiceV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1DebugForkChoiceV2{EthV1DebugForkChoiceV2: v} + } + iNdEx = postIndex + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1DebugForkChoiceReorgV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1DebugForkChoiceReorgV2); ok { + if err := oneof.EthV1DebugForkChoiceReorgV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1DebugForkChoiceReOrgV2DataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1DebugForkChoiceReorgV2{EthV1DebugForkChoiceReorgV2: v} + } + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockAttesterSlashing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockAttesterSlashing); ok { + if err := oneof.EthV2BeaconBlockAttesterSlashing.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockAttesterSlashingDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockAttesterSlashing{EthV2BeaconBlockAttesterSlashing: v} + } + iNdEx = postIndex + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockProposerSlashing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockProposerSlashing); ok { + if err := oneof.EthV2BeaconBlockProposerSlashing.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockProposerSlashingDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockProposerSlashing{EthV2BeaconBlockProposerSlashing: v} + } + iNdEx = postIndex + case 37: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockVoluntaryExit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockVoluntaryExit); ok { + if err := oneof.EthV2BeaconBlockVoluntaryExit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockVoluntaryExitDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockVoluntaryExit{EthV2BeaconBlockVoluntaryExit: v} + } + iNdEx = postIndex + case 38: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockDeposit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockDeposit); ok { + if err := oneof.EthV2BeaconBlockDeposit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockDepositDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockDeposit{EthV2BeaconBlockDeposit: v} + } + iNdEx = postIndex + case 39: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockBlsToExecutionChange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockBlsToExecutionChange); ok { + if err := oneof.EthV2BeaconBlockBlsToExecutionChange.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockBLSToExecutionChangeDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockBlsToExecutionChange{EthV2BeaconBlockBlsToExecutionChange: v} + } + iNdEx = postIndex + case 40: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockExecutionTransaction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockExecutionTransaction); ok { + if err := oneof.EthV2BeaconBlockExecutionTransaction.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockExecutionTransactionDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockExecutionTransaction{EthV2BeaconBlockExecutionTransaction: v} + } + iNdEx = postIndex + case 41: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockWithdrawal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockWithdrawal); ok { + if err := oneof.EthV2BeaconBlockWithdrawal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockWithdrawalDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockWithdrawal{EthV2BeaconBlockWithdrawal: v} + } + iNdEx = postIndex + case 42: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsBlobSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsBlobSidecar); ok { + if err := oneof.EthV1EventsBlobSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsBlobSidecarDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsBlobSidecar{EthV1EventsBlobSidecar: v} + } + iNdEx = postIndex + case 44: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconBlobSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1BeaconBlobSidecar); ok { + if err := oneof.EthV1BeaconBlobSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1BeaconBlobSidecarDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1BeaconBlobSidecar{EthV1BeaconBlobSidecar: v} + } + iNdEx = postIndex + case 45: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BeaconP2PAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_BeaconP2PAttestation); ok { + if err := oneof.BeaconP2PAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalBeaconP2PAttestationDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_BeaconP2PAttestation{BeaconP2PAttestation: v} + } + iNdEx = postIndex + case 46: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1ProposerDuty", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1ProposerDuty); ok { + if err := oneof.EthV1ProposerDuty.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1ProposerDutyDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1ProposerDuty{EthV1ProposerDuty: v} + } + iNdEx = postIndex + case 47: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockElaboratedAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockElaboratedAttestation); ok { + if err := oneof.EthV2BeaconBlockElaboratedAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockElaboratedAttestationDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockElaboratedAttestation{EthV2BeaconBlockElaboratedAttestation: v} + } + iNdEx = postIndex + case 48: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceAddPeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceAddPeer); ok { + if err := oneof.Libp2PTraceAddPeer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceAddPeerDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceAddPeer{Libp2PTraceAddPeer: v} + } + iNdEx = postIndex + case 49: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRemovePeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRemovePeer); ok { + if err := oneof.Libp2PTraceRemovePeer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRemovePeerDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRemovePeer{Libp2PTraceRemovePeer: v} + } + iNdEx = postIndex + case 50: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRecvRpc", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRecvRpc); ok { + if err := oneof.Libp2PTraceRecvRpc.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRecvRPCDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRecvRpc{Libp2PTraceRecvRpc: v} + } + iNdEx = postIndex + case 51: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceSendRpc", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceSendRpc); ok { + if err := oneof.Libp2PTraceSendRpc.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceSendRPCDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceSendRpc{Libp2PTraceSendRpc: v} + } + iNdEx = postIndex + case 52: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceJoin", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceJoin); ok { + if err := oneof.Libp2PTraceJoin.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceJoinDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceJoin{Libp2PTraceJoin: v} + } + iNdEx = postIndex + case 53: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceConnected", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceConnected); ok { + if err := oneof.Libp2PTraceConnected.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceConnectedDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceConnected{Libp2PTraceConnected: v} + } + iNdEx = postIndex + case 54: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceDisconnected", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceDisconnected); ok { + if err := oneof.Libp2PTraceDisconnected.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceDisconnectedDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceDisconnected{Libp2PTraceDisconnected: v} + } + iNdEx = postIndex + case 55: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceHandleMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceHandleMetadata); ok { + if err := oneof.Libp2PTraceHandleMetadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceHandleMetadataDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceHandleMetadata{Libp2PTraceHandleMetadata: v} + } + iNdEx = postIndex + case 56: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceHandleStatus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceHandleStatus); ok { + if err := oneof.Libp2PTraceHandleStatus.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceHandleStatusDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceHandleStatus{Libp2PTraceHandleStatus: v} + } + iNdEx = postIndex + case 57: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubBeaconBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubBeaconBlock); ok { + if err := oneof.Libp2PTraceGossipsubBeaconBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceGossipSubBeaconBlockDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceGossipsubBeaconBlock{Libp2PTraceGossipsubBeaconBlock: v} + } + iNdEx = postIndex + case 58: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubBeaconAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubBeaconAttestation); ok { + if err := oneof.Libp2PTraceGossipsubBeaconAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceGossipSubBeaconAttestationDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceGossipsubBeaconAttestation{Libp2PTraceGossipsubBeaconAttestation: v} + } + iNdEx = postIndex + case 59: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubBlobSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubBlobSidecar); ok { + if err := oneof.Libp2PTraceGossipsubBlobSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceGossipSubBlobSidecarDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceGossipsubBlobSidecar{Libp2PTraceGossipsubBlobSidecar: v} + } + iNdEx = postIndex + case 60: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1Validators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1Validators); ok { + if err := oneof.EthV1Validators.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1ValidatorsDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1Validators{EthV1Validators: v} + } + iNdEx = postIndex + case 61: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MevRelayBidTraceBuilderBlockSubmission", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MevRelayBidTraceBuilderBlockSubmission); ok { + if err := oneof.MevRelayBidTraceBuilderBlockSubmission.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalMevRelayBidTraceBuilderBlockSubmissionDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_MevRelayBidTraceBuilderBlockSubmission{MevRelayBidTraceBuilderBlockSubmission: v} + } + iNdEx = postIndex + case 62: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MevRelayPayloadDelivered", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MevRelayPayloadDelivered); ok { + if err := oneof.MevRelayPayloadDelivered.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalMevRelayPayloadDeliveredDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_MevRelayPayloadDelivered{MevRelayPayloadDelivered: v} + } + iNdEx = postIndex + case 63: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ModuleName", wireType) + } + m.ModuleName = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ModuleName |= ModuleName(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 64: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PresetName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PresetName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 65: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV3ValidatorBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV3ValidatorBlock); ok { + if err := oneof.EthV3ValidatorBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV3ValidatorBlockDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV3ValidatorBlock{EthV3ValidatorBlock: v} + } + iNdEx = postIndex + case 66: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MevRelayValidatorRegistration", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_MevRelayValidatorRegistration); ok { + if err := oneof.MevRelayValidatorRegistration.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalMevRelayValidatorRegistrationDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_MevRelayValidatorRegistration{MevRelayValidatorRegistration: v} + } + iNdEx = postIndex + case 67: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsBlockGossip", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsBlockGossip); ok { + if err := oneof.EthV1EventsBlockGossip.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsBlockGossipDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsBlockGossip{EthV1EventsBlockGossip: v} + } + iNdEx = postIndex + case 68: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceDropRpc", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceDropRpc); ok { + if err := oneof.Libp2PTraceDropRpc.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceDropRPCDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceDropRpc{Libp2PTraceDropRpc: v} + } + iNdEx = postIndex + case 69: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceLeave", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceLeave); ok { + if err := oneof.Libp2PTraceLeave.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceLeaveDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceLeave{Libp2PTraceLeave: v} + } + iNdEx = postIndex + case 70: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGraft", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGraft); ok { + if err := oneof.Libp2PTraceGraft.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceGraftDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceGraft{Libp2PTraceGraft: v} + } + iNdEx = postIndex + case 71: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTracePrune", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTracePrune); ok { + if err := oneof.Libp2PTracePrune.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTracePruneDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTracePrune{Libp2PTracePrune: v} + } + iNdEx = postIndex + case 72: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceDuplicateMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceDuplicateMessage); ok { + if err := oneof.Libp2PTraceDuplicateMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceDuplicateMessageDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceDuplicateMessage{Libp2PTraceDuplicateMessage: v} + } + iNdEx = postIndex + case 73: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceDeliverMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceDeliverMessage); ok { + if err := oneof.Libp2PTraceDeliverMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceDeliverMessageDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceDeliverMessage{Libp2PTraceDeliverMessage: v} + } + iNdEx = postIndex + case 74: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTracePublishMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTracePublishMessage); ok { + if err := oneof.Libp2PTracePublishMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTracePublishMessageDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTracePublishMessage{Libp2PTracePublishMessage: v} + } + iNdEx = postIndex + case 75: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRejectMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRejectMessage); ok { + if err := oneof.Libp2PTraceRejectMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRejectMessageDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRejectMessage{Libp2PTraceRejectMessage: v} + } + iNdEx = postIndex + case 76: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlIhave", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlIhave); ok { + if err := oneof.Libp2PTraceRpcMetaControlIhave.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRPCMetaControlIHaveDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRpcMetaControlIhave{Libp2PTraceRpcMetaControlIhave: v} + } + iNdEx = postIndex + case 77: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlIwant", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlIwant); ok { + if err := oneof.Libp2PTraceRpcMetaControlIwant.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRPCMetaControlIWantDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRpcMetaControlIwant{Libp2PTraceRpcMetaControlIwant: v} + } + iNdEx = postIndex + case 78: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlIdontwant", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlIdontwant); ok { + if err := oneof.Libp2PTraceRpcMetaControlIdontwant.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRPCMetaControlIDontWantDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRpcMetaControlIdontwant{Libp2PTraceRpcMetaControlIdontwant: v} + } + iNdEx = postIndex + case 79: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlGraft", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlGraft); ok { + if err := oneof.Libp2PTraceRpcMetaControlGraft.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRPCMetaControlGraftDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRpcMetaControlGraft{Libp2PTraceRpcMetaControlGraft: v} + } + iNdEx = postIndex + case 80: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlPrune", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaControlPrune); ok { + if err := oneof.Libp2PTraceRpcMetaControlPrune.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRPCMetaControlPruneDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRpcMetaControlPrune{Libp2PTraceRpcMetaControlPrune: v} + } + iNdEx = postIndex + case 81: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaSubscription", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaSubscription); ok { + if err := oneof.Libp2PTraceRpcMetaSubscription.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRPCMetaSubscriptionDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRpcMetaSubscription{Libp2PTraceRpcMetaSubscription: v} + } + iNdEx = postIndex + case 82: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcMetaMessage); ok { + if err := oneof.Libp2PTraceRpcMetaMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRPCMetaMessageDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRpcMetaMessage{Libp2PTraceRpcMetaMessage: v} + } + iNdEx = postIndex + case 83: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecordConsensus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_NodeRecordConsensus); ok { + if err := oneof.NodeRecordConsensus.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalNodeRecordConsensusDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_NodeRecordConsensus{NodeRecordConsensus: v} + } + iNdEx = postIndex + case 84: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubAggregateAndProof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubAggregateAndProof); ok { + if err := oneof.Libp2PTraceGossipsubAggregateAndProof.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceGossipSubAggregateAndProofDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceGossipsubAggregateAndProof{Libp2PTraceGossipsubAggregateAndProof: v} + } + iNdEx = postIndex + case 85: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsDataColumnSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1EventsDataColumnSidecar); ok { + if err := oneof.EthV1EventsDataColumnSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1EventsDataColumnSidecarDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1EventsDataColumnSidecar{EthV1EventsDataColumnSidecar: v} + } + iNdEx = postIndex + case 86: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubDataColumnSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceGossipsubDataColumnSidecar); ok { + if err := oneof.Libp2PTraceGossipsubDataColumnSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceGossipSubDataColumnSidecarDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceGossipsubDataColumnSidecar{Libp2PTraceGossipsubDataColumnSidecar: v} + } + iNdEx = postIndex + case 87: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceSyntheticHeartbeat", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceSyntheticHeartbeat); ok { + if err := oneof.Libp2PTraceSyntheticHeartbeat.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceSyntheticHeartbeatDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceSyntheticHeartbeat{Libp2PTraceSyntheticHeartbeat: v} + } + iNdEx = postIndex + case 88: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcDataColumnCustodyProbe", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceRpcDataColumnCustodyProbe); ok { + if err := oneof.Libp2PTraceRpcDataColumnCustodyProbe.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceRpcDataColumnCustodyProbeDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceRpcDataColumnCustodyProbe{Libp2PTraceRpcDataColumnCustodyProbe: v} + } + iNdEx = postIndex + case 89: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusEngineApiNewPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_ConsensusEngineApiNewPayload); ok { + if err := oneof.ConsensusEngineApiNewPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalConsensusEngineAPINewPayloadDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_ConsensusEngineApiNewPayload{ConsensusEngineApiNewPayload: v} + } + iNdEx = postIndex + case 90: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusEngineApiGetBlobs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_ConsensusEngineApiGetBlobs); ok { + if err := oneof.ConsensusEngineApiGetBlobs.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalConsensusEngineAPIGetBlobsDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_ConsensusEngineApiGetBlobs{ConsensusEngineApiGetBlobs: v} + } + iNdEx = postIndex + case 91: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconBlob", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1BeaconBlob); ok { + if err := oneof.EthV1BeaconBlob.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1BeaconBlobDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1BeaconBlob{EthV1BeaconBlob: v} + } + iNdEx = postIndex + case 92: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconSyncCommittee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV1BeaconSyncCommittee); ok { + if err := oneof.EthV1BeaconSyncCommittee.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV1BeaconSyncCommitteeDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV1BeaconSyncCommittee{EthV1BeaconSyncCommittee: v} + } + iNdEx = postIndex + case 93: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockSyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_EthV2BeaconBlockSyncAggregate); ok { + if err := oneof.EthV2BeaconBlockSyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalEthV2BeaconBlockSyncAggregateDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_EthV2BeaconBlockSyncAggregate{EthV2BeaconBlockSyncAggregate: v} + } + iNdEx = postIndex + case 94: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceIdentify", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ClientMeta_Libp2PTraceIdentify); ok { + if err := oneof.Libp2PTraceIdentify.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ClientMeta_AdditionalLibP2PTraceIdentifyDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ClientMeta_Libp2PTraceIdentify{Libp2PTraceIdentify: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_Event) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_Event: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_Event: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceivedDateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReceivedDateTime == nil { + m.ReceivedDateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.ReceivedDateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_Geo) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_Geo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_Geo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field City", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.City = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Country", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Country = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CountryCode", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CountryCode = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContinentCode", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContinentCode = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Latitude", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Latitude = float64(math.Float64frombits(v)) + case 6: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Longitude", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Longitude = float64(math.Float64frombits(v)) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AutonomousSystemNumber", wireType) + } + m.AutonomousSystemNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AutonomousSystemNumber |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AutonomousSystemOrganization", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AutonomousSystemOrganization = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_Client) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_Client: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_Client: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IP = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Geo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Geo == nil { + m.Geo = ServerMeta_GeoFromVTPool() + } + if err := m.Geo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Group = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.User = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_Peer) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_Peer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_Peer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Geo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Geo == nil { + m.Geo = ServerMeta_GeoFromVTPool() + } + if err := m.Geo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_AdditionalBeaconP2PAttestationData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_AdditionalBeaconP2PAttestationData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_AdditionalBeaconP2PAttestationData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Peer == nil { + m.Peer = ServerMeta_PeerFromVTPool() + } + if err := m.Peer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_AdditionalLibp2PTraceConnectedData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_AdditionalLibp2PTraceConnectedData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_AdditionalLibp2PTraceConnectedData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Peer == nil { + m.Peer = ServerMeta_PeerFromVTPool() + } + if err := m.Peer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_AdditionalLibp2PTraceDisconnectedData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_AdditionalLibp2PTraceDisconnectedData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_AdditionalLibp2PTraceDisconnectedData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Peer == nil { + m.Peer = ServerMeta_PeerFromVTPool() + } + if err := m.Peer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Peer == nil { + m.Peer = ServerMeta_PeerFromVTPool() + } + if err := m.Peer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_AdditionalLibp2PTraceIdentifyData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_AdditionalLibp2PTraceIdentifyData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_AdditionalLibp2PTraceIdentifyData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Peer == nil { + m.Peer = ServerMeta_PeerFromVTPool() + } + if err := m.Peer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_AdditionalNodeRecordConsensusData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_AdditionalNodeRecordConsensusData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_AdditionalNodeRecordConsensusData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Geo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Geo == nil { + m.Geo = ServerMeta_GeoFromVTPool() + } + if err := m.Geo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta_AdditionalNodeRecordExecutionData) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta_AdditionalNodeRecordExecutionData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta_AdditionalNodeRecordExecutionData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Geo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Geo == nil { + m.Geo = ServerMeta_GeoFromVTPool() + } + if err := m.Geo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ServerMeta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ServerMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ServerMeta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Event == nil { + m.Event = ServerMeta_EventFromVTPool() + } + if err := m.Event.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Client", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Client == nil { + m.Client = ServerMeta_ClientFromVTPool() + } + if err := m.Client.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BEACON_P2P_ATTESTATION", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ServerMeta_BEACON_P2P_ATTESTATION); ok { + if err := oneof.BEACON_P2P_ATTESTATION.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ServerMeta_AdditionalBeaconP2PAttestationDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ServerMeta_BEACON_P2P_ATTESTATION{BEACON_P2P_ATTESTATION: v} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LIBP2P_TRACE_CONNECTED", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ServerMeta_LIBP2P_TRACE_CONNECTED); ok { + if err := oneof.LIBP2P_TRACE_CONNECTED.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ServerMeta_AdditionalLibp2PTraceConnectedDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ServerMeta_LIBP2P_TRACE_CONNECTED{LIBP2P_TRACE_CONNECTED: v} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LIBP2P_TRACE_DISCONNECTED", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ServerMeta_LIBP2P_TRACE_DISCONNECTED); ok { + if err := oneof.LIBP2P_TRACE_DISCONNECTED.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ServerMeta_AdditionalLibp2PTraceDisconnectedDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ServerMeta_LIBP2P_TRACE_DISCONNECTED{LIBP2P_TRACE_DISCONNECTED: v} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NODE_RECORD_CONSENSUS", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ServerMeta_NODE_RECORD_CONSENSUS); ok { + if err := oneof.NODE_RECORD_CONSENSUS.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ServerMeta_AdditionalNodeRecordConsensusDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ServerMeta_NODE_RECORD_CONSENSUS{NODE_RECORD_CONSENSUS: v} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NODE_RECORD_EXECUTION", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ServerMeta_NODE_RECORD_EXECUTION); ok { + if err := oneof.NODE_RECORD_EXECUTION.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ServerMeta_AdditionalNodeRecordExecutionDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ServerMeta_NODE_RECORD_EXECUTION{NODE_RECORD_EXECUTION: v} + } + iNdEx = postIndex + case 42: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LIBP2P_TRACE_SYNTHETIC_HEARTBEAT", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ServerMeta_LIBP2P_TRACE_SYNTHETIC_HEARTBEAT); ok { + if err := oneof.LIBP2P_TRACE_SYNTHETIC_HEARTBEAT.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ServerMeta_AdditionalLibP2PTraceSyntheticHeartbeatDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ServerMeta_LIBP2P_TRACE_SYNTHETIC_HEARTBEAT{LIBP2P_TRACE_SYNTHETIC_HEARTBEAT: v} + } + iNdEx = postIndex + case 43: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LIBP2P_TRACE_IDENTIFY", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.AdditionalData.(*ServerMeta_LIBP2P_TRACE_IDENTIFY); ok { + if err := oneof.LIBP2P_TRACE_IDENTIFY.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ServerMeta_AdditionalLibp2PTraceIdentifyDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.AdditionalData = &ServerMeta_LIBP2P_TRACE_IDENTIFY{LIBP2P_TRACE_IDENTIFY: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Meta) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Meta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Meta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Client", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Client == nil { + m.Client = ClientMetaFromVTPool() + } + if err := m.Client.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Server", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Server == nil { + m.Server = ServerMetaFromVTPool() + } + if err := m.Server.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Event) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Event: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + m.Name = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Name |= Event_Name(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DateTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DateTime == nil { + m.DateTime = ×tamppb1.Timestamp{} + } + if err := (*timestamppb.Timestamp)(m.DateTime).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionBlockMetrics_StateReads) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionBlockMetrics_StateReads: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionBlockMetrics_StateReads: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Accounts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Accounts == nil { + m.Accounts = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Accounts).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageSlots", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StorageSlots == nil { + m.StorageSlots = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.StorageSlots).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Code == nil { + m.Code = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Code).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CodeBytes == nil { + m.CodeBytes = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.CodeBytes).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionBlockMetrics_StateWrites) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionBlockMetrics_StateWrites: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionBlockMetrics_StateWrites: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Accounts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Accounts == nil { + m.Accounts = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Accounts).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AccountsDeleted", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AccountsDeleted == nil { + m.AccountsDeleted = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.AccountsDeleted).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageSlots", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StorageSlots == nil { + m.StorageSlots = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.StorageSlots).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageSlotsDeleted", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StorageSlotsDeleted == nil { + m.StorageSlotsDeleted = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.StorageSlotsDeleted).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Code == nil { + m.Code = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.Code).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CodeBytes == nil { + m.CodeBytes = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.CodeBytes).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionBlockMetrics_CacheEntry) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionBlockMetrics_CacheEntry: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionBlockMetrics_CacheEntry: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Hits == nil { + m.Hits = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.Hits).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Misses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Misses == nil { + m.Misses = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.Misses).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HitRate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HitRate == nil { + m.HitRate = &wrapperspb1.DoubleValue{} + } + if err := (*wrapperspb.DoubleValue)(m.HitRate).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionBlockMetrics_CodeCacheEntry) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionBlockMetrics_CodeCacheEntry: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionBlockMetrics_CodeCacheEntry: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hits", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Hits == nil { + m.Hits = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.Hits).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Misses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Misses == nil { + m.Misses = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.Misses).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HitRate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HitRate == nil { + m.HitRate = &wrapperspb1.DoubleValue{} + } + if err := (*wrapperspb.DoubleValue)(m.HitRate).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HitBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.HitBytes == nil { + m.HitBytes = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.HitBytes).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MissBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MissBytes == nil { + m.MissBytes = &wrapperspb1.Int64Value{} + } + if err := (*wrapperspb.Int64Value)(m.MissBytes).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExecutionBlockMetrics) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExecutionBlockMetrics: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExecutionBlockMetrics: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Source = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockNumber == nil { + m.BlockNumber = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.BlockNumber).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &wrapperspb1.UInt64Value{} + } + if err := (*wrapperspb.UInt64Value)(m.GasUsed).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxCount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TxCount == nil { + m.TxCount = &wrapperspb1.UInt32Value{} + } + if err := (*wrapperspb.UInt32Value)(m.TxCount).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecutionMs == nil { + m.ExecutionMs = &wrapperspb1.DoubleValue{} + } + if err := (*wrapperspb.DoubleValue)(m.ExecutionMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateReadMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateReadMs == nil { + m.StateReadMs = &wrapperspb1.DoubleValue{} + } + if err := (*wrapperspb.DoubleValue)(m.StateReadMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateHashMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateHashMs == nil { + m.StateHashMs = &wrapperspb1.DoubleValue{} + } + if err := (*wrapperspb.DoubleValue)(m.StateHashMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CommitMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CommitMs == nil { + m.CommitMs = &wrapperspb1.DoubleValue{} + } + if err := (*wrapperspb.DoubleValue)(m.CommitMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalMs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TotalMs == nil { + m.TotalMs = &wrapperspb1.DoubleValue{} + } + if err := (*wrapperspb.DoubleValue)(m.TotalMs).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MgasPerSec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MgasPerSec == nil { + m.MgasPerSec = &wrapperspb1.DoubleValue{} + } + if err := (*wrapperspb.DoubleValue)(m.MgasPerSec).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateReads", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateReads == nil { + m.StateReads = ExecutionBlockMetrics_StateReadsFromVTPool() + } + if err := m.StateReads.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateWrites", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateWrites == nil { + m.StateWrites = ExecutionBlockMetrics_StateWritesFromVTPool() + } + if err := m.StateWrites.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AccountCache", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AccountCache == nil { + m.AccountCache = ExecutionBlockMetrics_CacheEntryFromVTPool() + } + if err := m.AccountCache.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageCache", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StorageCache == nil { + m.StorageCache = ExecutionBlockMetrics_CacheEntryFromVTPool() + } + if err := m.StorageCache.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeCache", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CodeCache == nil { + m.CodeCache = ExecutionBlockMetrics_CodeCacheEntryFromVTPool() + } + if err := m.CodeCache.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DecoratedEvent) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DecoratedEvent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DecoratedEvent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Event == nil { + m.Event = EventFromVTPool() + } + if err := m.Event.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Meta == nil { + m.Meta = MetaFromVTPool() + } + if err := m.Meta.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsAttestation); ok { + if err := oneof.EthV1EventsAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.AttestationFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsAttestation{EthV1EventsAttestation: v} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsBlock); ok { + if err := oneof.EthV1EventsBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventBlockFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsBlock{EthV1EventsBlock: v} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsChainReorg", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsChainReorg); ok { + if err := oneof.EthV1EventsChainReorg.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventChainReorgFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsChainReorg{EthV1EventsChainReorg: v} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsFinalizedCheckpoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsFinalizedCheckpoint); ok { + if err := oneof.EthV1EventsFinalizedCheckpoint.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventFinalizedCheckpointFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsFinalizedCheckpoint{EthV1EventsFinalizedCheckpoint: v} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsHead", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsHead); ok { + if err := oneof.EthV1EventsHead.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventHeadFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsHead{EthV1EventsHead: v} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsVoluntaryExit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsVoluntaryExit); ok { + if err := oneof.EthV1EventsVoluntaryExit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventVoluntaryExitFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsVoluntaryExit{EthV1EventsVoluntaryExit: v} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsContributionAndProof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsContributionAndProof); ok { + if err := oneof.EthV1EventsContributionAndProof.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventContributionAndProofFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsContributionAndProof{EthV1EventsContributionAndProof: v} + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MempoolTransaction", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = &DecoratedEvent_MempoolTransaction{MempoolTransaction: string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlock); ok { + if err := oneof.EthV2BeaconBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v2.EventBlockFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlock{EthV2BeaconBlock: v} + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1ForkChoice", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ForkChoice); ok { + if err := oneof.EthV1ForkChoice.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.ForkChoiceFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1ForkChoice{EthV1ForkChoice: v} + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1ForkChoiceReorg", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ForkChoiceReorg); ok { + if err := oneof.EthV1ForkChoiceReorg.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := DebugForkChoiceReorgFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1ForkChoiceReorg{EthV1ForkChoiceReorg: v} + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconCommittee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1BeaconCommittee); ok { + if err := oneof.EthV1BeaconCommittee.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.CommitteeFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1BeaconCommittee{EthV1BeaconCommittee: v} + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1ValidatorAttestationData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ValidatorAttestationData); ok { + if err := oneof.EthV1ValidatorAttestationData.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.AttestationDataV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1ValidatorAttestationData{EthV1ValidatorAttestationData: v} + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsAttestationV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsAttestationV2); ok { + if err := oneof.EthV1EventsAttestationV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.AttestationV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsAttestationV2{EthV1EventsAttestationV2: v} + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsBlockV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsBlockV2); ok { + if err := oneof.EthV1EventsBlockV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventBlockV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsBlockV2{EthV1EventsBlockV2: v} + } + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsChainReorgV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsChainReorgV2); ok { + if err := oneof.EthV1EventsChainReorgV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventChainReorgV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsChainReorgV2{EthV1EventsChainReorgV2: v} + } + iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsFinalizedCheckpointV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsFinalizedCheckpointV2); ok { + if err := oneof.EthV1EventsFinalizedCheckpointV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventFinalizedCheckpointV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsFinalizedCheckpointV2{EthV1EventsFinalizedCheckpointV2: v} + } + iNdEx = postIndex + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsHeadV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsHeadV2); ok { + if err := oneof.EthV1EventsHeadV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventHeadV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsHeadV2{EthV1EventsHeadV2: v} + } + iNdEx = postIndex + case 21: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsVoluntaryExitV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsVoluntaryExitV2); ok { + if err := oneof.EthV1EventsVoluntaryExitV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventVoluntaryExitV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsVoluntaryExitV2{EthV1EventsVoluntaryExitV2: v} + } + iNdEx = postIndex + case 22: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsContributionAndProofV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsContributionAndProofV2); ok { + if err := oneof.EthV1EventsContributionAndProofV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventContributionAndProofV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsContributionAndProofV2{EthV1EventsContributionAndProofV2: v} + } + iNdEx = postIndex + case 23: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MempoolTransactionV2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = &DecoratedEvent_MempoolTransactionV2{MempoolTransactionV2: string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + case 24: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockV2); ok { + if err := oneof.EthV2BeaconBlockV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v2.EventBlockV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockV2{EthV2BeaconBlockV2: v} + } + iNdEx = postIndex + case 25: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1ForkChoiceV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ForkChoiceV2); ok { + if err := oneof.EthV1ForkChoiceV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.ForkChoiceV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1ForkChoiceV2{EthV1ForkChoiceV2: v} + } + iNdEx = postIndex + case 26: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1ForkChoiceReorgV2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ForkChoiceReorgV2); ok { + if err := oneof.EthV1ForkChoiceReorgV2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := DebugForkChoiceReorgV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1ForkChoiceReorgV2{EthV1ForkChoiceReorgV2: v} + } + iNdEx = postIndex + case 27: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockAttesterSlashing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockAttesterSlashing); ok { + if err := oneof.EthV2BeaconBlockAttesterSlashing.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.AttesterSlashingV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockAttesterSlashing{EthV2BeaconBlockAttesterSlashing: v} + } + iNdEx = postIndex + case 28: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockProposerSlashing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockProposerSlashing); ok { + if err := oneof.EthV2BeaconBlockProposerSlashing.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.ProposerSlashingV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockProposerSlashing{EthV2BeaconBlockProposerSlashing: v} + } + iNdEx = postIndex + case 29: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockVoluntaryExit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockVoluntaryExit); ok { + if err := oneof.EthV2BeaconBlockVoluntaryExit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.SignedVoluntaryExitV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockVoluntaryExit{EthV2BeaconBlockVoluntaryExit: v} + } + iNdEx = postIndex + case 30: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockDeposit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockDeposit); ok { + if err := oneof.EthV2BeaconBlockDeposit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.DepositV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockDeposit{EthV2BeaconBlockDeposit: v} + } + iNdEx = postIndex + case 31: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockBlsToExecutionChange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockBlsToExecutionChange); ok { + if err := oneof.EthV2BeaconBlockBlsToExecutionChange.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v2.SignedBLSToExecutionChangeV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockBlsToExecutionChange{EthV2BeaconBlockBlsToExecutionChange: v} + } + iNdEx = postIndex + case 32: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockExecutionTransaction", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockExecutionTransaction); ok { + if err := oneof.EthV2BeaconBlockExecutionTransaction.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.TransactionFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockExecutionTransaction{EthV2BeaconBlockExecutionTransaction: v} + } + iNdEx = postIndex + case 33: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockWithdrawal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockWithdrawal); ok { + if err := oneof.EthV2BeaconBlockWithdrawal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.WithdrawalV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockWithdrawal{EthV2BeaconBlockWithdrawal: v} + } + iNdEx = postIndex + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsBlobSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsBlobSidecar); ok { + if err := oneof.EthV1EventsBlobSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventBlobSidecarFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsBlobSidecar{EthV1EventsBlobSidecar: v} + } + iNdEx = postIndex + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconBlockBlobSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1BeaconBlockBlobSidecar); ok { + if err := oneof.EthV1BeaconBlockBlobSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.BlobSidecarFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1BeaconBlockBlobSidecar{EthV1BeaconBlockBlobSidecar: v} + } + iNdEx = postIndex + case 37: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BeaconP2PAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_BeaconP2PAttestation); ok { + if err := oneof.BeaconP2PAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.AttestationV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_BeaconP2PAttestation{BeaconP2PAttestation: v} + } + iNdEx = postIndex + case 38: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1ProposerDuty", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1ProposerDuty); ok { + if err := oneof.EthV1ProposerDuty.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.ProposerDutyFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1ProposerDuty{EthV1ProposerDuty: v} + } + iNdEx = postIndex + case 39: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockElaboratedAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockElaboratedAttestation); ok { + if err := oneof.EthV2BeaconBlockElaboratedAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.ElaboratedAttestationFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockElaboratedAttestation{EthV2BeaconBlockElaboratedAttestation: v} + } + iNdEx = postIndex + case 40: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceAddPeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceAddPeer); ok { + if err := oneof.Libp2PTraceAddPeer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.AddPeerFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceAddPeer{Libp2PTraceAddPeer: v} + } + iNdEx = postIndex + case 41: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRemovePeer", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRemovePeer); ok { + if err := oneof.Libp2PTraceRemovePeer.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.RemovePeerFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRemovePeer{Libp2PTraceRemovePeer: v} + } + iNdEx = postIndex + case 42: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRecvRpc", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRecvRpc); ok { + if err := oneof.Libp2PTraceRecvRpc.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.RecvRPCFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRecvRpc{Libp2PTraceRecvRpc: v} + } + iNdEx = postIndex + case 43: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceSendRpc", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceSendRpc); ok { + if err := oneof.Libp2PTraceSendRpc.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.SendRPCFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceSendRpc{Libp2PTraceSendRpc: v} + } + iNdEx = postIndex + case 44: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceJoin", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceJoin); ok { + if err := oneof.Libp2PTraceJoin.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.JoinFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceJoin{Libp2PTraceJoin: v} + } + iNdEx = postIndex + case 45: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceConnected", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceConnected); ok { + if err := oneof.Libp2PTraceConnected.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.ConnectedFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceConnected{Libp2PTraceConnected: v} + } + iNdEx = postIndex + case 46: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceDisconnected", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceDisconnected); ok { + if err := oneof.Libp2PTraceDisconnected.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.DisconnectedFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceDisconnected{Libp2PTraceDisconnected: v} + } + iNdEx = postIndex + case 47: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceHandleMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceHandleMetadata); ok { + if err := oneof.Libp2PTraceHandleMetadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.HandleMetadataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceHandleMetadata{Libp2PTraceHandleMetadata: v} + } + iNdEx = postIndex + case 48: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceHandleStatus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceHandleStatus); ok { + if err := oneof.Libp2PTraceHandleStatus.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.HandleStatusFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceHandleStatus{Libp2PTraceHandleStatus: v} + } + iNdEx = postIndex + case 49: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubBeaconBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubBeaconBlock); ok { + if err := oneof.Libp2PTraceGossipsubBeaconBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := gossipsub.BeaconBlockFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceGossipsubBeaconBlock{Libp2PTraceGossipsubBeaconBlock: v} + } + iNdEx = postIndex + case 50: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubBeaconAttestation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubBeaconAttestation); ok { + if err := oneof.Libp2PTraceGossipsubBeaconAttestation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.AttestationFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceGossipsubBeaconAttestation{Libp2PTraceGossipsubBeaconAttestation: v} + } + iNdEx = postIndex + case 51: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubBlobSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubBlobSidecar); ok { + if err := oneof.Libp2PTraceGossipsubBlobSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := gossipsub.BlobSidecarFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceGossipsubBlobSidecar{Libp2PTraceGossipsubBlobSidecar: v} + } + iNdEx = postIndex + case 52: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1Validators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1Validators); ok { + if err := oneof.EthV1Validators.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ValidatorsFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1Validators{EthV1Validators: v} + } + iNdEx = postIndex + case 53: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MevRelayBidTraceBuilderBlockSubmission", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_MevRelayBidTraceBuilderBlockSubmission); ok { + if err := oneof.MevRelayBidTraceBuilderBlockSubmission.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := mevrelay.BidTraceFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_MevRelayBidTraceBuilderBlockSubmission{MevRelayBidTraceBuilderBlockSubmission: v} + } + iNdEx = postIndex + case 54: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MevRelayPayloadDelivered", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_MevRelayPayloadDelivered); ok { + if err := oneof.MevRelayPayloadDelivered.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := mevrelay.ProposerPayloadDeliveredFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_MevRelayPayloadDelivered{MevRelayPayloadDelivered: v} + } + iNdEx = postIndex + case 55: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV3ValidatorBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV3ValidatorBlock); ok { + if err := oneof.EthV3ValidatorBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v2.EventBlockV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV3ValidatorBlock{EthV3ValidatorBlock: v} + } + iNdEx = postIndex + case 56: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MevRelayValidatorRegistration", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_MevRelayValidatorRegistration); ok { + if err := oneof.MevRelayValidatorRegistration.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := mevrelay.ValidatorRegistrationFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_MevRelayValidatorRegistration{MevRelayValidatorRegistration: v} + } + iNdEx = postIndex + case 57: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsBlockGossip", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsBlockGossip); ok { + if err := oneof.EthV1EventsBlockGossip.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventBlockGossipFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsBlockGossip{EthV1EventsBlockGossip: v} + } + iNdEx = postIndex + case 58: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceDropRpc", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceDropRpc); ok { + if err := oneof.Libp2PTraceDropRpc.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.DropRPCFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceDropRpc{Libp2PTraceDropRpc: v} + } + iNdEx = postIndex + case 59: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceLeave", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceLeave); ok { + if err := oneof.Libp2PTraceLeave.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.LeaveFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceLeave{Libp2PTraceLeave: v} + } + iNdEx = postIndex + case 60: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGraft", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGraft); ok { + if err := oneof.Libp2PTraceGraft.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.GraftFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceGraft{Libp2PTraceGraft: v} + } + iNdEx = postIndex + case 61: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTracePrune", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTracePrune); ok { + if err := oneof.Libp2PTracePrune.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.PruneFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTracePrune{Libp2PTracePrune: v} + } + iNdEx = postIndex + case 62: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceDuplicateMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceDuplicateMessage); ok { + if err := oneof.Libp2PTraceDuplicateMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.DuplicateMessageFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceDuplicateMessage{Libp2PTraceDuplicateMessage: v} + } + iNdEx = postIndex + case 63: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceDeliverMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceDeliverMessage); ok { + if err := oneof.Libp2PTraceDeliverMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.DeliverMessageFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceDeliverMessage{Libp2PTraceDeliverMessage: v} + } + iNdEx = postIndex + case 64: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTracePublishMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTracePublishMessage); ok { + if err := oneof.Libp2PTracePublishMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.PublishMessageFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTracePublishMessage{Libp2PTracePublishMessage: v} + } + iNdEx = postIndex + case 65: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRejectMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRejectMessage); ok { + if err := oneof.Libp2PTraceRejectMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.RejectMessageFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRejectMessage{Libp2PTraceRejectMessage: v} + } + iNdEx = postIndex + case 66: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlIhave", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlIhave); ok { + if err := oneof.Libp2PTraceRpcMetaControlIhave.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.ControlIHaveMetaItemFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRpcMetaControlIhave{Libp2PTraceRpcMetaControlIhave: v} + } + iNdEx = postIndex + case 67: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlIwant", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlIwant); ok { + if err := oneof.Libp2PTraceRpcMetaControlIwant.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.ControlIWantMetaItemFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRpcMetaControlIwant{Libp2PTraceRpcMetaControlIwant: v} + } + iNdEx = postIndex + case 68: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlIdontwant", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlIdontwant); ok { + if err := oneof.Libp2PTraceRpcMetaControlIdontwant.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.ControlIDontWantMetaItemFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRpcMetaControlIdontwant{Libp2PTraceRpcMetaControlIdontwant: v} + } + iNdEx = postIndex + case 69: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlGraft", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlGraft); ok { + if err := oneof.Libp2PTraceRpcMetaControlGraft.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.ControlGraftMetaItemFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRpcMetaControlGraft{Libp2PTraceRpcMetaControlGraft: v} + } + iNdEx = postIndex + case 70: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaControlPrune", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaControlPrune); ok { + if err := oneof.Libp2PTraceRpcMetaControlPrune.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.ControlPruneMetaItemFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRpcMetaControlPrune{Libp2PTraceRpcMetaControlPrune: v} + } + iNdEx = postIndex + case 71: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaSubscription", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaSubscription); ok { + if err := oneof.Libp2PTraceRpcMetaSubscription.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.SubMetaItemFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRpcMetaSubscription{Libp2PTraceRpcMetaSubscription: v} + } + iNdEx = postIndex + case 72: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcMetaMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcMetaMessage); ok { + if err := oneof.Libp2PTraceRpcMetaMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.MessageMetaItemFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRpcMetaMessage{Libp2PTraceRpcMetaMessage: v} + } + iNdEx = postIndex + case 73: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecordConsensus", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_NodeRecordConsensus); ok { + if err := oneof.NodeRecordConsensus.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := noderecord.ConsensusFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_NodeRecordConsensus{NodeRecordConsensus: v} + } + iNdEx = postIndex + case 74: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeRecordExecution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_NodeRecordExecution); ok { + if err := oneof.NodeRecordExecution.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := noderecord.ExecutionFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_NodeRecordExecution{NodeRecordExecution: v} + } + iNdEx = postIndex + case 75: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubAggregateAndProof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubAggregateAndProof); ok { + if err := oneof.Libp2PTraceGossipsubAggregateAndProof.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.SignedAggregateAttestationAndProofV2FromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceGossipsubAggregateAndProof{Libp2PTraceGossipsubAggregateAndProof: v} + } + iNdEx = postIndex + case 76: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1EventsDataColumnSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1EventsDataColumnSidecar); ok { + if err := oneof.EthV1EventsDataColumnSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.EventDataColumnSidecarFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1EventsDataColumnSidecar{EthV1EventsDataColumnSidecar: v} + } + iNdEx = postIndex + case 77: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceGossipsubDataColumnSidecar", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceGossipsubDataColumnSidecar); ok { + if err := oneof.Libp2PTraceGossipsubDataColumnSidecar.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := gossipsub.DataColumnSidecarFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceGossipsubDataColumnSidecar{Libp2PTraceGossipsubDataColumnSidecar: v} + } + iNdEx = postIndex + case 78: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceSyntheticHeartbeat", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceSyntheticHeartbeat); ok { + if err := oneof.Libp2PTraceSyntheticHeartbeat.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.SyntheticHeartbeatFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceSyntheticHeartbeat{Libp2PTraceSyntheticHeartbeat: v} + } + iNdEx = postIndex + case 79: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceIdentify", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceIdentify); ok { + if err := oneof.Libp2PTraceIdentify.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.IdentifyFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceIdentify{Libp2PTraceIdentify: v} + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Libp2PTraceRpcDataColumnCustodyProbe", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_Libp2PTraceRpcDataColumnCustodyProbe); ok { + if err := oneof.Libp2PTraceRpcDataColumnCustodyProbe.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := libp2p.DataColumnCustodyProbeFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_Libp2PTraceRpcDataColumnCustodyProbe{Libp2PTraceRpcDataColumnCustodyProbe: v} + } + iNdEx = postIndex + case 201: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionStateSize", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_ExecutionStateSize); ok { + if err := oneof.ExecutionStateSize.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ExecutionStateSizeFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_ExecutionStateSize{ExecutionStateSize: v} + } + iNdEx = postIndex + case 202: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusEngineApiNewPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_ConsensusEngineApiNewPayload); ok { + if err := oneof.ConsensusEngineApiNewPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ConsensusEngineAPINewPayloadFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_ConsensusEngineApiNewPayload{ConsensusEngineApiNewPayload: v} + } + iNdEx = postIndex + case 203: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusEngineApiGetBlobs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_ConsensusEngineApiGetBlobs); ok { + if err := oneof.ConsensusEngineApiGetBlobs.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ConsensusEngineAPIGetBlobsFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_ConsensusEngineApiGetBlobs{ConsensusEngineApiGetBlobs: v} + } + iNdEx = postIndex + case 204: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionEngineNewPayload", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_ExecutionEngineNewPayload); ok { + if err := oneof.ExecutionEngineNewPayload.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ExecutionEngineNewPayloadFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_ExecutionEngineNewPayload{ExecutionEngineNewPayload: v} + } + iNdEx = postIndex + case 205: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionEngineGetBlobs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_ExecutionEngineGetBlobs); ok { + if err := oneof.ExecutionEngineGetBlobs.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ExecutionEngineGetBlobsFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_ExecutionEngineGetBlobs{ExecutionEngineGetBlobs: v} + } + iNdEx = postIndex + case 206: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconBlob", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1BeaconBlob); ok { + if err := oneof.EthV1BeaconBlob.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := v1.BlobFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1BeaconBlob{EthV1BeaconBlob: v} + } + iNdEx = postIndex + case 207: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV1BeaconSyncCommittee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV1BeaconSyncCommittee); ok { + if err := oneof.EthV1BeaconSyncCommittee.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := SyncCommitteeDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV1BeaconSyncCommittee{EthV1BeaconSyncCommittee: v} + } + iNdEx = postIndex + case 208: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EthV2BeaconBlockSyncAggregate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_EthV2BeaconBlockSyncAggregate); ok { + if err := oneof.EthV2BeaconBlockSyncAggregate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := SyncAggregateDataFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_EthV2BeaconBlockSyncAggregate{EthV2BeaconBlockSyncAggregate: v} + } + iNdEx = postIndex + case 209: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecutionBlockMetrics", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*DecoratedEvent_ExecutionBlockMetrics); ok { + if err := oneof.ExecutionBlockMetrics.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := ExecutionBlockMetricsFromVTPool() + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &DecoratedEvent_ExecutionBlockMetrics{ExecutionBlockMetrics: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +}