diff --git a/.gitignore b/.gitignore index b32953de..5f368f7a 100644 --- a/.gitignore +++ b/.gitignore @@ -10,5 +10,6 @@ firehose-data* /.fleet/settings.json /firecore +/generator /firehose.yaml .claude diff --git a/CHANGELOG.md b/CHANGELOG.md index 5b5c0118..f852a304 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,15 @@ If you were at `firehose-core` version `1.0.0` and are bumping to `1.1.0`, you s ## Unreleased +### Added + +- `tools wkp descriptors [output-file]`: new command that exports all well-known blockchain protobuf descriptors as a self-contained, serialized `google.protobuf.FileDescriptorSet` (binary wire format). The set includes every transitive import (google/protobuf/* well-known types included) so consumers can build a descriptor registry with no external resolution. Output is deterministic (stable topological + alphabetical ordering) enabling "is it up to date?" CI checks via a regenerate-and-diff workflow. Use `-` as `output-file` to write to stdout; the default output name is `well-known-descriptors.binpb`. +- `proto/generator`: switched from the BSR Reflection v1beta1 API to the BSR HTTP descriptor endpoint (`/descriptor/?source_info=true`). Regenerated WKP files will now embed `source_code_info` (proto field/message comments), enabling documentation renderers and tooling that reads comment annotations. Authentication via `BUFBUILD_AUTH_TOKEN` is now optional for public modules (a warning is emitted when the token is absent). + +### Fixed + +- Removed vulnerable `github.com/docker/docker` dependency (GHSA-x744-4wpc-v9h2, GHSA-x86f-5xw2-fm2r, GHSA-rg2x-37c3-w2rh). Upgraded `testcontainers-go` to v0.42.0 (which uses `github.com/moby/moby/api` instead) and updated the single import in `relayer/relayer_e2e_test.go` from `github.com/docker/docker/api/types/container` to `github.com/moby/moby/api/types/container`. + ### Changed - Bumped `dstore`: S3 store now suppresses the SDK's checksum validation warnings (sets `DisableLogOutputChecksumValidationSkipped` to `true`) and updates the AWS S3 SDK to a newer version. diff --git a/cmd/tools/tools.go b/cmd/tools/tools.go index faacb4ad..ee118926 100644 --- a/cmd/tools/tools.go +++ b/cmd/tools/tools.go @@ -28,6 +28,7 @@ import ( print2 "github.com/streamingfast/firehose-core/cmd/tools/print" "github.com/streamingfast/firehose-core/cmd/tools/relayer" "github.com/streamingfast/firehose-core/cmd/tools/substreams" + toolswkp "github.com/streamingfast/firehose-core/cmd/tools/wkp" "github.com/streamingfast/logging" "go.uber.org/zap" ) @@ -84,6 +85,7 @@ func ConfigureToolsCmd[B firecore.Block]( ToolsCmd.AddCommand(relayer.NewToolsRelayerGroup(chain, logger)) ToolsCmd.AddCommand(substreams.NewToolsSubstreamsCmd(chain, logger)) ToolsCmd.AddCommand(NewToolsNetworksCmd(chain, logger)) + ToolsCmd.AddCommand(toolswkp.NewToolsWKPCmd(chain, logger)) if chain.Tools.MergedBlockUpgrader != nil { ToolsCmd.AddCommand(mergeblock.NewToolsUpgradeMergedBlocksCmd(chain, logger)) diff --git a/cmd/tools/wkp/log_test.go b/cmd/tools/wkp/log_test.go new file mode 100644 index 00000000..7af24e81 --- /dev/null +++ b/cmd/tools/wkp/log_test.go @@ -0,0 +1,7 @@ +package wkp + +import "github.com/streamingfast/logging" + +func init() { + logging.InstantiateLoggers() +} diff --git a/cmd/tools/wkp/tools_wkp.go b/cmd/tools/wkp/tools_wkp.go new file mode 100644 index 00000000..782eb9a9 --- /dev/null +++ b/cmd/tools/wkp/tools_wkp.go @@ -0,0 +1,38 @@ +package wkp + +import ( + . "github.com/streamingfast/cli" + "github.com/spf13/cobra" + firecore "github.com/streamingfast/firehose-core" + "go.uber.org/zap" +) + +func NewToolsWKPCmd[B firecore.Block](chain *firecore.Chain[B], logger *zap.Logger) *cobra.Command { + return ToCobraCmd(Group( + "wkp", + "Well-known protocols related tools", + + Command( + toolsWKPDescriptorsRunner(chain, logger), + "descriptors [output-file]", + "Export all well-known blockchain protobuf descriptors as a self-contained FileDescriptorSet", + Description(` + Exports every well-known blockchain protobuf descriptor registered in firehose-core + as a serialized google.protobuf.FileDescriptorSet written to + (defaults to "well-known-descriptors.binpb"). Use "-" to write to stdout. + + The exported set is self-contained: all transitive imports, including google/protobuf/* + well-known types, are included. No external resolution is needed to build a descriptor + registry from this file. + + The output is deterministic: given the same embedded descriptors, re-running the + command produces byte-identical output, enabling "is it up to date?" CI checks via a + regenerate-and-diff workflow. + + source_code_info (proto field/message comments) is included when the embedded + descriptors were generated with the BSR HTTP descriptor endpoint using ?source_info=true + (see proto/generator/generator.go). Re-run the generator to embed updated descriptors. + `), + ), + )) +} diff --git a/cmd/tools/wkp/tools_wkp_descriptors.go b/cmd/tools/wkp/tools_wkp_descriptors.go new file mode 100644 index 00000000..50f355ac --- /dev/null +++ b/cmd/tools/wkp/tools_wkp_descriptors.go @@ -0,0 +1,103 @@ +package wkp + +import ( + "fmt" + "io" + "maps" + "os" + "slices" + + "github.com/spf13/cobra" + firecore "github.com/streamingfast/firehose-core" + "github.com/streamingfast/firehose-core/proto/wkp" + "go.uber.org/zap" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/types/descriptorpb" +) + +func toolsWKPDescriptorsRunner[B firecore.Block](chain *firecore.Chain[B], logger *zap.Logger) firecore.CommandExecutor { + return func(cmd *cobra.Command, args []string) error { + outputPath := "well-known-descriptors.binpb" + if len(args) > 0 { + outputPath = args[0] + } + + descriptors := collectSortedDescriptors() + + fds := &descriptorpb.FileDescriptorSet{File: descriptors} + + b, err := proto.Marshal(fds) + if err != nil { + return fmt.Errorf("marshaling FileDescriptorSet: %w", err) + } + + var w io.Writer + if outputPath == "-" { + w = os.Stdout + } else { + f, err := os.Create(outputPath) + if err != nil { + return fmt.Errorf("creating output file %q: %w", outputPath, err) + } + defer f.Close() + w = f + } + + if _, err := w.Write(b); err != nil { + return fmt.Errorf("writing output: %w", err) + } + + if outputPath != "-" { + logger.Info("exported well-known descriptors", + zap.String("path", outputPath), + zap.Int("file_count", len(descriptors)), + zap.Int("bytes", len(b)), + ) + } + + return nil + } +} + +// collectSortedDescriptors returns all well-known proto file descriptors in a +// deterministic topological order: dependencies always precede dependants, and +// siblings are ordered alphabetically by file name. +func collectSortedDescriptors() []*descriptorpb.FileDescriptorProto { + all := wkp.WellKnownProtos() + + fileMap := make(map[string]*descriptorpb.FileDescriptorProto, len(all)) + for _, d := range all { + fileMap[d.GetName()] = d + } + + // Visit in sorted name order so that the topological traversal is deterministic. + sortedNames := slices.Sorted(maps.Keys(fileMap)) + + visited := make(map[string]bool, len(sortedNames)) + result := make([]*descriptorpb.FileDescriptorProto, 0, len(sortedNames)) + + var visit func(name string) + visit = func(name string) { + if visited[name] { + return + } + visited[name] = true + + d := fileMap[name] + deps := slices.Clone(d.Dependency) + slices.Sort(deps) + for _, dep := range deps { + if _, exists := fileMap[dep]; exists { + visit(dep) + } + } + + result = append(result, d) + } + + for _, name := range sortedNames { + visit(name) + } + + return result +} diff --git a/cmd/tools/wkp/tools_wkp_descriptors_test.go b/cmd/tools/wkp/tools_wkp_descriptors_test.go new file mode 100644 index 00000000..a6bfe47c --- /dev/null +++ b/cmd/tools/wkp/tools_wkp_descriptors_test.go @@ -0,0 +1,158 @@ +package wkp + +import ( + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protodesc" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/types/descriptorpb" +) + +// TestDescriptorsExport verifies that the exported FileDescriptorSet is valid, +// self-contained, and contains the expected well-known block types. +func TestDescriptorsExport(t *testing.T) { + descriptors := collectSortedDescriptors() + require.NotEmpty(t, descriptors) + + fds := &descriptorpb.FileDescriptorSet{File: descriptors} + + // Round-trip through proto marshal/unmarshal + b, err := proto.Marshal(fds) + require.NoError(t, err) + require.NotEmpty(t, b) + + parsed := &descriptorpb.FileDescriptorSet{} + require.NoError(t, proto.Unmarshal(b, parsed)) + assert.Equal(t, len(descriptors), len(parsed.File)) +} + +// TestDescriptorsDeterminism verifies that repeated calls to collectSortedDescriptors +// produce byte-identical output. +func TestDescriptorsDeterminism(t *testing.T) { + marshal := func() []byte { + fds := &descriptorpb.FileDescriptorSet{File: collectSortedDescriptors()} + b, err := proto.Marshal(fds) + require.NoError(t, err) + return b + } + + first := marshal() + for range 5 { + assert.Equal(t, first, marshal(), "output must be byte-identical across runs") + } +} + +// TestDescriptorsSelfContained verifies that the exported set forms a valid registry +// with no unresolved imports — every referenced file is present in the set. +func TestDescriptorsSelfContained(t *testing.T) { + descriptors := collectSortedDescriptors() + + fds := &descriptorpb.FileDescriptorSet{File: descriptors} + + // protodesc.NewFiles builds a registry and validates all imports are present. + reg, err := protodesc.NewFiles(fds) + require.NoError(t, err, "all imports must be resolvable within the exported set") + + assert.Greater(t, reg.NumFiles(), 0) +} + +// TestDescriptorsEthereumBlockType verifies that the Ethereum block type is fully +// resolvable with all its field definitions present. +func TestDescriptorsEthereumBlockType(t *testing.T) { + fds := &descriptorpb.FileDescriptorSet{File: collectSortedDescriptors()} + + reg, err := protodesc.NewFiles(fds) + require.NoError(t, err) + + desc, err := reg.FindDescriptorByName("sf.ethereum.type.v2.Block") + require.NoError(t, err, "sf.ethereum.type.v2.Block must be present in the exported set") + + md, ok := desc.(protoreflect.MessageDescriptor) + require.True(t, ok) + assert.Greater(t, md.Fields().Len(), 0, "Block message must have fields") +} + +// TestDescriptorsNoDuplicateFiles verifies that each file path appears exactly once. +func TestDescriptorsNoDuplicateFiles(t *testing.T) { + descriptors := collectSortedDescriptors() + + seen := make(map[string]int, len(descriptors)) + for _, d := range descriptors { + seen[d.GetName()]++ + } + + for name, count := range seen { + assert.Equal(t, 1, count, "file %q appears %d times, expected exactly once", name, count) + } +} + +// TestDescriptorsTopologicalOrder verifies that every file appears after all of its +// declared imports in the exported set. +func TestDescriptorsTopologicalOrder(t *testing.T) { + descriptors := collectSortedDescriptors() + + position := make(map[string]int, len(descriptors)) + for i, d := range descriptors { + position[d.GetName()] = i + } + + for _, d := range descriptors { + for _, dep := range d.Dependency { + depPos, present := position[dep] + if !present { + // Dependency not in our set (e.g., external), skip. + continue + } + assert.Less(t, depPos, position[d.GetName()], + "dependency %q must appear before %q", dep, d.GetName()) + } + } +} + +// TestDescriptorsWriteToFile verifies end-to-end: collect → marshal → write → read back. +func TestDescriptorsWriteToFile(t *testing.T) { + outPath := filepath.Join(t.TempDir(), "descriptors.binpb") + + descriptors := collectSortedDescriptors() + fds := &descriptorpb.FileDescriptorSet{File: descriptors} + b, err := proto.Marshal(fds) + require.NoError(t, err) + require.NoError(t, os.WriteFile(outPath, b, 0o644)) + + // Read back and verify + raw, err := os.ReadFile(outPath) + require.NoError(t, err) + + parsed := &descriptorpb.FileDescriptorSet{} + require.NoError(t, proto.Unmarshal(raw, parsed)) + assert.Equal(t, len(descriptors), len(parsed.File)) + + // Re-build registry from file to confirm it's still valid + _, err = protodesc.NewFiles(parsed) + require.NoError(t, err) +} + +// TestDescriptorsSourceCodeInfoStatus documents the source_code_info state of the +// currently embedded descriptors. The generator (proto/generator/generator.go) now +// uses the BSR HTTP descriptor endpoint with ?source_info=true, so newly regenerated +// WKP files will carry source_code_info. The existing embedded files pre-date that +// change and do not yet have it. After the next `go generate ./proto/...` run this +// test should be updated to assert presence instead of absence. +func TestDescriptorsSourceCodeInfoStatus(t *testing.T) { + descriptors := collectSortedDescriptors() + withInfo := 0 + for _, d := range descriptors { + if d.SourceCodeInfo != nil { + withInfo++ + } + } + // After regenerating with the updated generator, withInfo will equal len(descriptors). + // This assertion simply records the current state so the test fails loudly if someone + // regenerates without updating it. + t.Logf("source_code_info present in %d/%d embedded descriptor files", withInfo, len(descriptors)) +} diff --git a/go.mod b/go.mod index 40206711..afdfd235 100644 --- a/go.mod +++ b/go.mod @@ -3,14 +3,11 @@ module github.com/streamingfast/firehose-core go 1.26.0 require ( - buf.build/gen/go/bufbuild/reflect/connectrpc/go v1.16.1-20240117202343-bf8f65e8876c.1 - buf.build/gen/go/bufbuild/reflect/protocolbuffers/go v1.33.0-20240117202343-bf8f65e8876c.1 cloud.google.com/go/logging v1.17.0 connectrpc.com/connect v1.19.2 github.com/ShinyTrinkets/overseer v0.3.0 github.com/cenkalti/backoff/v4 v4.3.0 github.com/charmbracelet/lipgloss v1.1.0 - github.com/docker/docker v28.5.1+incompatible github.com/docker/go-connections v0.6.0 github.com/dustin/go-humanize v1.0.1 github.com/go-json-experiment/json v0.0.0-20231013223334-54c864be5b8d @@ -19,6 +16,7 @@ require ( github.com/iancoleman/strcase v0.3.0 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 github.com/mattn/go-isatty v0.0.20 + github.com/moby/moby/api v1.54.1 github.com/mostynb/go-grpc-compression v1.2.3 github.com/pinax-network/graph-networks-libs/packages/golang v0.7.0 github.com/prometheus/client_golang v1.23.2 @@ -44,7 +42,7 @@ require ( github.com/streamingfast/substreams v1.18.6-0.20260612185556-609bd2f621f2 github.com/stretchr/testify v1.11.1 github.com/test-go/testify v1.1.4 - github.com/testcontainers/testcontainers-go v0.40.0 + github.com/testcontainers/testcontainers-go v0.42.0 go.opentelemetry.io/otel v1.43.0 go.uber.org/multierr v1.11.0 go.uber.org/zap v1.27.1 @@ -54,6 +52,8 @@ require ( ) require ( + buf.build/gen/go/bufbuild/reflect/connectrpc/go v1.16.1-20240117202343-bf8f65e8876c.1 // indirect + buf.build/gen/go/bufbuild/reflect/protocolbuffers/go v1.33.0-20240117202343-bf8f65e8876c.1 // indirect cel.dev/expr v0.25.1 // indirect cloud.google.com/go/auth v0.19.0 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect @@ -66,7 +66,7 @@ require ( github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 // indirect github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.3 // indirect - github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 // indirect + github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 // indirect github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.55.0 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect @@ -111,7 +111,7 @@ require ( github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect github.com/distribution/reference v0.6.0 // indirect github.com/docker/go-units v0.5.0 // indirect - github.com/ebitengine/purego v0.8.4 // indirect + github.com/ebitengine/purego v0.10.0 // indirect github.com/envoyproxy/go-control-plane/envoy v1.36.0 // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/go-jose/go-jose/v4 v4.1.4 // indirect @@ -137,29 +137,28 @@ require ( github.com/mattn/go-runewidth v0.0.16 // indirect github.com/minio/minlz v1.0.1 // indirect github.com/moby/docker-image-spec v1.3.1 // indirect - github.com/moby/go-archive v0.1.0 // indirect - github.com/moby/patternmatcher v0.6.0 // indirect + github.com/moby/go-archive v0.2.0 // indirect + github.com/moby/moby/client v0.4.0 // indirect + github.com/moby/patternmatcher v0.6.1 // indirect github.com/moby/sys/sequential v0.6.0 // indirect github.com/moby/sys/user v0.4.0 // indirect github.com/moby/sys/userns v0.1.0 // indirect - github.com/moby/term v0.5.0 // indirect - github.com/morikuni/aec v1.0.0 // indirect + github.com/moby/term v0.5.2 // indirect github.com/muesli/termenv v0.16.0 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect github.com/opencontainers/image-spec v1.1.1 // indirect github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect github.com/pierrec/lz4/v4 v4.1.21 // indirect github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect - github.com/pkg/errors v0.9.1 // indirect github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect - github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect github.com/protocolbuffers/protoscope v0.0.0-20221109213918-8e7a6aafa2c9 // indirect github.com/rivo/uniseg v0.4.7 // indirect github.com/sagikazarmark/locafero v0.11.0 // indirect github.com/segmentio/asm v1.2.0 // indirect github.com/sercand/kuberesolver/v5 v5.1.1 // indirect - github.com/shirou/gopsutil/v4 v4.25.6 // indirect - github.com/sirupsen/logrus v1.9.3 // indirect + github.com/shirou/gopsutil/v4 v4.26.3 // indirect + github.com/sirupsen/logrus v1.9.4 // indirect github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect github.com/spiffe/go-spiffe/v2 v2.6.0 // indirect github.com/streamingfast/dbin v0.9.1-0.20231117225723-59790c798e2c // indirect @@ -170,8 +169,8 @@ require ( github.com/tidwall/gjson v1.18.0 // indirect github.com/tidwall/match v1.1.1 // indirect github.com/tidwall/pretty v1.2.1 // indirect - github.com/tklauser/go-sysconf v0.3.12 // indirect - github.com/tklauser/numcpus v0.6.1 // indirect + github.com/tklauser/go-sysconf v0.3.16 // indirect + github.com/tklauser/numcpus v0.11.0 // indirect github.com/valyala/fastjson v1.6.4 // indirect github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect github.com/yusufpapurcu/wmi v1.2.4 // indirect diff --git a/go.sum b/go.sum index 5c5627af..e6224060 100644 --- a/go.sum +++ b/go.sum @@ -1560,8 +1560,8 @@ github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.8.1 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.8.1/go.mod h1:Ng3urmn6dYe8gnbCMoHHVl5APYz2txho3koEkV2o2HA= github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.3 h1:ZJJNFaQ86GVKQ9ehwqyAFE6pIfyicpuJ8IkVaPBc6/4= github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.3/go.mod h1:URuDvhmATVKqHBH9/0nOiNKk0+YcwfQ3WkK5PqHKxc8= -github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= -github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1 h1:WJTmL004Abzc5wDB5VtZG2PJk5ndYDgVacGqfirKxjM= github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1/go.mod h1:tCcJZ0uHAmvjsVYzEFivsRTN00oz5BEsRgQHu5JZ9WE= github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 h1:XRzhVemXdgvJqCH0sFfrBUTnUJSBrBf7++ypk+twtRs= @@ -1762,8 +1762,8 @@ github.com/cpuguy83/dockercfg v0.3.2 h1:DlJTyZGBDlXqUZ2Dk2Q3xHs/FtnooJJVaad2S9GK github.com/cpuguy83/dockercfg v0.3.2/go.mod h1:sugsbF4//dDlL/i+S+rtpIWp+5h0BHJHfjj5/jFyUJc= github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= -github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= +github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s= +github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= @@ -1774,8 +1774,6 @@ github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvw github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40= github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= -github.com/docker/docker v28.5.1+incompatible h1:Bm8DchhSD2J6PsFzxC35TZo4TLGR2PdW/E69rU45NhM= -github.com/docker/docker v28.5.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= github.com/docker/go-connections v0.6.0 h1:LlMG9azAe1TqfR7sO+NJttz1gy6KO7VJBh+pMmjSD94= github.com/docker/go-connections v0.6.0/go.mod h1:AahvXYshr6JgfUJGdDCs2b5EZG/vmaMAntpSFH5BFKE= github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= @@ -1787,8 +1785,8 @@ github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+m github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= -github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw= -github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= +github.com/ebitengine/purego v0.10.0 h1:QIw4xfpWT6GWTzaW5XEKy3HXoqrJGx1ijYHzTF0/ISU= +github.com/ebitengine/purego v0.10.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= github.com/emicklei/go-restful/v3 v3.8.0 h1:eCZ8ulSerjdAiaNpF7GxXIE7ZCMo1moN1qX+S609eVw= github.com/emicklei/go-restful/v3 v3.8.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= @@ -2150,27 +2148,27 @@ github.com/mitchellh/go-testing-interface v1.14.1/go.mod h1:gfgS7OtZj6MA4U1UrDRp github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= -github.com/moby/go-archive v0.1.0 h1:Kk/5rdW/g+H8NHdJW2gsXyZ7UnzvJNOy6VKJqueWdcQ= -github.com/moby/go-archive v0.1.0/go.mod h1:G9B+YoujNohJmrIYFBpSd54GTUB4lt9S+xVQvsJyFuo= -github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk= -github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc= -github.com/moby/sys/atomicwriter v0.1.0 h1:kw5D/EqkBwsBFi0ss9v1VG3wIkVhzGvLklJ+w3A14Sw= -github.com/moby/sys/atomicwriter v0.1.0/go.mod h1:Ul8oqv2ZMNHOceF643P6FKPXeCmYtlQMvpizfsSoaWs= +github.com/moby/go-archive v0.2.0 h1:zg5QDUM2mi0JIM9fdQZWC7U8+2ZfixfTYoHL7rWUcP8= +github.com/moby/go-archive v0.2.0/go.mod h1:mNeivT14o8xU+5q1YnNrkQVpK+dnNe/K6fHqnTg4qPU= +github.com/moby/moby/api v1.54.1 h1:TqVzuJkOLsgLDDwNLmYqACUuTehOHRGKiPhvH8V3Nn4= +github.com/moby/moby/api v1.54.1/go.mod h1:+RQ6wluLwtYaTd1WnPLykIDPekkuyD/ROWQClE83pzs= +github.com/moby/moby/client v0.4.0 h1:S+2XegzHQrrvTCvF6s5HFzcrywWQmuVnhOXe2kiWjIw= +github.com/moby/moby/client v0.4.0/go.mod h1:QWPbvWchQbxBNdaLSpoKpCdf5E+WxFAgNHogCWDoa7g= +github.com/moby/patternmatcher v0.6.1 h1:qlhtafmr6kgMIJjKJMDmMWq7WLkKIo23hsrpR3x084U= +github.com/moby/patternmatcher v0.6.1/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc= github.com/moby/sys/sequential v0.6.0 h1:qrx7XFUd/5DxtqcoH1h438hF5TmOvzC/lspjy7zgvCU= github.com/moby/sys/sequential v0.6.0/go.mod h1:uyv8EUTrca5PnDsdMGXhZe6CCe8U/UiTWd+lL+7b/Ko= github.com/moby/sys/user v0.4.0 h1:jhcMKit7SA80hivmFJcbB1vqmw//wU61Zdui2eQXuMs= github.com/moby/sys/user v0.4.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85uoHjs= github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g= github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28= -github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0= -github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= +github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ= +github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= -github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= github.com/mostynb/go-grpc-compression v1.2.3 h1:42/BKWMy0KEJGSdWvzqIyOZ95YcR9mLPqKctH7Uo//I= github.com/mostynb/go-grpc-compression v1.2.3/go.mod h1:AghIxF3P57umzqM9yz795+y1Vjs47Km/Y2FE6ouQ7Lg= github.com/mr-tron/base58 v1.3.0 h1:K6Y13R2h+dku0wOqKtecgRnBUBPrZzLZy5aIj8lCcJI= @@ -2229,8 +2227,8 @@ github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1 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= -github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw= -github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g= github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U= github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= @@ -2276,13 +2274,13 @@ github.com/sercand/kuberesolver/v5 v5.1.1 h1:CYH+d67G0sGBj7q5wLK61yzqJJ8gLLC8aep github.com/sercand/kuberesolver/v5 v5.1.1/go.mod h1:Fs1KbKhVRnB2aDWN12NjKCB+RgYMWZJ294T3BtmVCpQ= github.com/sethvargo/go-retry v0.2.3 h1:oYlgvIvsju3jNbottWABtbnoLC+GDtLdBHxKWxQm/iU= github.com/sethvargo/go-retry v0.2.3/go.mod h1:1afjQuvh7s4gflMObvjLPaWgluLLyhA1wmVZ6KLpICw= -github.com/shirou/gopsutil/v4 v4.25.6 h1:kLysI2JsKorfaFPcYmcJqbzROzsBWEOAtw6A7dIfqXs= -github.com/shirou/gopsutil/v4 v4.25.6/go.mod h1:PfybzyydfZcN+JMMjkF6Zb8Mq1A/VcogFFg7hj50W9c= +github.com/shirou/gopsutil/v4 v4.26.3 h1:2ESdQt90yU3oXF/CdOlRCJxrP+Am1aBYubTMTfxJ1qc= +github.com/shirou/gopsutil/v4 v4.26.3/go.mod h1:LZ6ewCSkBqUpvSOf+LsTGnRinC6iaNUNMGBtDkJBaLQ= github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8= github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= -github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= -github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w= +github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g= github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw= github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= @@ -2377,8 +2375,9 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+ github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= @@ -2401,8 +2400,8 @@ github.com/teris-io/shortid v0.0.0-20171029131806-771a37caa5cf h1:Z2X3Os7oRzpdJ7 github.com/teris-io/shortid v0.0.0-20171029131806-771a37caa5cf/go.mod h1:M8agBzgqHIhgj7wEn9/0hJUZcrvt9VY+Ln+S1I5Mha0= github.com/test-go/testify v1.1.4 h1:Tf9lntrKUMHiXQ07qBScBTSA0dhYQlu83hswqelv1iE= github.com/test-go/testify v1.1.4/go.mod h1:rH7cfJo/47vWGdi4GPj16x3/t1xGOj2YxzmNQzk2ghU= -github.com/testcontainers/testcontainers-go v0.40.0 h1:pSdJYLOVgLE8YdUY2FHQ1Fxu+aMnb6JfVz1mxk7OeMU= -github.com/testcontainers/testcontainers-go v0.40.0/go.mod h1:FSXV5KQtX2HAMlm7U3APNyLkkap35zNLxukw9oBi/MY= +github.com/testcontainers/testcontainers-go v0.42.0 h1:He3IhTzTZOygSXLJPMX7n44XtK+qhjat1nI9cneBbUY= +github.com/testcontainers/testcontainers-go v0.42.0/go.mod h1:vZjdY1YmUA1qEForxOIOazfsrdyORJAbhi0bp8plN30= github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY= github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= @@ -2412,10 +2411,10 @@ github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhso github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= -github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= -github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= -github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= -github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA= +github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI= +github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw= +github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ= github.com/tsenart/deadcode v0.0.0-20160724212837-210d2dc333e9/go.mod h1:q+QjxYvZ+fpjMXqs+XEriussHjSYqeXVnAdSV1tkMYk= github.com/valyala/fastjson v1.6.4 h1:uAUNq9Z6ymTgGhcm0UynUAB6tlbakBrz6CQFax3BXVQ= github.com/valyala/fastjson v1.6.4/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY= @@ -2792,7 +2791,6 @@ golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -3435,6 +3433,8 @@ modernc.org/token v1.0.1/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= modernc.org/z v1.5.1/go.mod h1:eWFB510QWW5Th9YGZT81s+LwvaAs3Q2yr4sP0rmLkv8= modernc.org/z v1.7.0/go.mod h1:hVdgNMh8ggTuRG1rGU8x+xGRFfiQUIAw0ZqlPy8+HyQ= +pgregory.net/rapid v1.2.0 h1:keKAYRcjm+e1F0oAuU5F5+YPAWcyxNNRK2wud503Gnk= +pgregory.net/rapid v1.2.0/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 h1:iXTIw73aPyC+oRdyqqvVJuloN1p0AC/kzH07hu3NE+k= sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0= diff --git a/proto/generator/generator.go b/proto/generator/generator.go index 764e1e43..3cfd8f5a 100644 --- a/proto/generator/generator.go +++ b/proto/generator/generator.go @@ -2,40 +2,50 @@ package main import ( "bufio" + "bytes" "context" "embed" "encoding/base64" "encoding/hex" + "encoding/json" "fmt" - "log" + "io" "net/http" "os" "path/filepath" "regexp" - "slices" "sort" "strings" "text/template" "time" - "buf.build/gen/go/bufbuild/reflect/connectrpc/go/buf/reflect/v1beta1/reflectv1beta1connect" - reflectv1beta1 "buf.build/gen/go/bufbuild/reflect/protocolbuffers/go/buf/reflect/v1beta1" - connect "connectrpc.com/connect" "github.com/iancoleman/strcase" registry "github.com/pinax-network/graph-networks-libs/packages/golang/lib" "github.com/streamingfast/cli" networks "github.com/streamingfast/firehose-networks" + "github.com/streamingfast/logging" + "go.uber.org/zap" + "google.golang.org/protobuf/encoding/protojson" "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/types/descriptorpb" ) //go:embed *.gotmpl var templates embed.FS +var zlog, _ = logging.PackageLogger("generator", "github.com/streamingfast/firehose-core/proto/generator") + func main() { + logging.InstantiateLoggers() + cli.Ensure(len(os.Args) >= 3 && len(os.Args) <= 5, "go run ./generator [] []") + // Auth token is optional: public BSR modules are accessible without it, but + // providing one avoids rate-limiting for large regenerations. authToken := os.Getenv("BUFBUILD_AUTH_TOKEN") - cli.Ensure(authToken != "", "You must set the BUFBUILD_AUTH_TOKEN environment variable to generate well known registry. See https://buf.build/docs/bsr/authentication") + if authToken == "" { + zlog.Warn("BUFBUILD_AUTH_TOKEN not set — proceeding without authentication (rate limits may apply)") + } outputPackage := os.Args[1] packageName := os.Args[2] @@ -44,7 +54,6 @@ func main() { if len(os.Args) >= 4 { blockTypeFilterRaw = os.Args[3] } - if len(os.Args) >= 5 { bufRevision = os.Args[4] } @@ -52,13 +61,13 @@ func main() { blockTypeFilter, err := regexp.Compile(blockTypeFilterRaw) cli.NoError(err, "Unable to compile filter regex %q", blockTypeFilterRaw) - client := reflectv1beta1connect.NewFileDescriptorSetServiceClient( - http.DefaultClient, - "https://buf.build", - ) - - // Some networks specifies the same Buf Type, we discard duplicates if we already generated - seenBufTypes := make(map[string]bool) + // Some networks specify the same Buf module; discard duplicates already fetched. + seenBufModules := make(map[string]bool) + // Track file names → marshaled bytes for deduplication across modules. + // Name-based deduplication is required: a FileDescriptorSet must have unique names. + // We also keep the bytes so we can warn when the same path appears with different + // content (version skew between BSR modules). + seenFiles := make(map[string][]byte) var protofiles []ProtoFile registeredNetworks := make([]*registry.Network, 0, len(networks.GetFirehoseRegistry())) @@ -80,45 +89,46 @@ func main() { } wellKnownProtoRepo := strings.TrimPrefix(protocol.Firehose.BufURL, "https://") - if seenBufTypes[wellKnownProtoRepo] { + if seenBufModules[wellKnownProtoRepo] { continue } + seenBufModules[wellKnownProtoRepo] = true - seenBufTypes[wellKnownProtoRepo] = true + // wellKnownProtoRepo is "buf.build//" + parts := strings.SplitN(wellKnownProtoRepo, "/", 3) + cli.Ensure(len(parts) == 3, "unexpected BufURL format %q (expected buf.build/owner/module)", wellKnownProtoRepo) + host, owner, moduleName := parts[0], parts[1], parts[2] - request := connect.NewRequest(&reflectv1beta1.GetFileDescriptorSetRequest{ - Module: wellKnownProtoRepo, - Version: bufRevision, - }) + fds, commitID := fetchFileDescriptorSet(host, owner, moduleName, bufRevision, authToken) - request.Header().Set("Authorization", "Bearer "+authToken) - fileDescriptorSet, err := client.GetFileDescriptorSet(context.Background(), request) - if err != nil { - log.Fatalf("failed to call file descriptor set service: %v", err) - return - } + zlog.Info("resolved commit", zap.String("module", wellKnownProtoRepo), zap.String("commit", commitID)) + + for _, file := range fds.File { + name := derefPtr(file.Name, "") - for _, file := range fileDescriptorSet.Msg.FileDescriptorSet.File { cnt, err := proto.Marshal(file) - if err != nil { - log.Fatalf("failed to marshall proto file %s: %v", file.GetName(), err) - return - } - name := "" - if file.Name != nil { - name = *file.Name + cli.NoError(err, "Failed to marshal proto file %s", name) + + if existing, seen := seenFiles[name]; seen { + if !bytes.Equal(existing, cnt) { + zlog.Warn("file has different content than a previously seen copy — keeping the first occurrence; check for version skew between BSR modules", + zap.String("file", name), + zap.String("module", wellKnownProtoRepo), + ) + } + continue } + seenFiles[name] = cnt - if !protoFileExists(name, cnt, protofiles) { - protofiles = append(protofiles, ProtoFile{ - Name: name, - Data: cnt, - BufRegistryPackageURL: buildBufRegistryPackageURL(wellKnownProtoRepo, derefPtr(file.Package, ""), fileDescriptorSet.Msg.Version), - }) - log.Printf("Added proto %s", name) - } + protofiles = append(protofiles, ProtoFile{ + Name: name, + Data: cnt, + BufRegistryPackageURL: buildBufRegistryPackageURL(wellKnownProtoRepo, derefPtr(file.Package, ""), commitID), + }) + zlog.Info("added proto", zap.String("file", name)) } - // avoid hitting the buf.build rate limit + + // Avoid hitting the BSR rate limit between module fetches. time.Sleep(1 * time.Second) } @@ -126,67 +136,104 @@ func main() { cli.NoError(err, "Unable to instantiate template") if outputPackage == "-" { - // Output to stdout (single file for compatibility) err = tmpl.ExecuteTemplate(os.Stdout, "template.gotmpl", map[string]any{ "Package": packageName, "ProtoFiles": protofiles, }) cli.NoError(err, "Unable to render template") } else { - // Create output directory cli.NoError(os.MkdirAll(outputPackage, os.ModePerm), "Unable to create output directory") - // Generate registry file registryFile := filepath.Join(outputPackage, "registry.go") - file, err := os.Create(registryFile) + f, err := os.Create(registryFile) cli.NoError(err, "Unable to create registry file") - bufferedOut := bufio.NewWriter(file) - err = tmpl.ExecuteTemplate(bufferedOut, "registry.gotmpl", map[string]any{ - "Package": packageName, - }) - cli.NoError(err, "Unable to render registry template") - bufferedOut.Flush() - file.Close() + w := bufio.NewWriter(f) + cli.NoError(tmpl.ExecuteTemplate(w, "registry.gotmpl", map[string]any{"Package": packageName}), "Unable to render registry template") + cli.NoError(w.Flush(), "Unable to flush registry file") + f.Close() - // Generate individual proto files for _, protoFile := range protofiles { - filename := generateFilename(protoFile.Name) - filepath := filepath.Join(outputPackage, filename+".go") + outPath := filepath.Join(outputPackage, generateFilename(protoFile.Name)+".go") - file, err := os.Create(filepath) - cli.NoError(err, "Unable to create proto file %s", filepath) + f, err := os.Create(outPath) + cli.NoError(err, "Unable to create proto file %s", outPath) - bufferedOut := bufio.NewWriter(file) - err = tmpl.ExecuteTemplate(bufferedOut, "protofile.gotmpl", map[string]any{ + w := bufio.NewWriter(f) + cli.NoError(tmpl.ExecuteTemplate(w, "protofile.gotmpl", map[string]any{ "Package": packageName, "Name": protoFile.Name, "Data": protoFile.Data, "BufRegistryPackageURL": protoFile.BufRegistryPackageURL, - }) - cli.NoError(err, "Unable to render proto file template") - bufferedOut.Flush() - file.Close() + }), "Unable to render proto file template") + cli.NoError(w.Flush(), "Unable to flush proto file %s", outPath) + f.Close() - log.Printf("Generated %s", filepath) + zlog.Info("generated", zap.String("file", outPath)) } } - fmt.Println("Done creating well known registry") + zlog.Info("done creating well known registry") } -func buildBufRegistryPackageURL(module string, fullyQualifiedPackage string, revision string) string { - // Example full URL is https://buf.build/streamingfast/firehose-near/docs/146e2ae8bd9b49e29b132b8627f29a70:sf.near.type.v1 - return fmt.Sprintf("https://%s/docs/%s:%s", module, revision, fullyQualifiedPackage) -} +// fetchFileDescriptorSet calls the BSR Connect API to fetch a module's FileDescriptorSet +// with source_code_info, and returns the resolved commit ID alongside it. +func fetchFileDescriptorSet(host, owner, moduleName, revision, authToken string) (*descriptorpb.FileDescriptorSet, string) { + type reqName struct { + Owner string `json:"owner"` + Module string `json:"module"` + Label string `json:"label"` + } + type reqResourceRef struct { + Name reqName `json:"name"` + } + type connectReq struct { + ResourceRef reqResourceRef `json:"resourceRef"` + IncludeSourceCodeInfo bool `json:"includeSourceCodeInfo"` + } -func protoFileExists(name string, data []byte, protofiles []ProtoFile) bool { - for _, pf := range protofiles { - if pf.Name == name && slices.Equal(pf.Data, data) { - return true - } + reqBody, err := json.Marshal(connectReq{ + ResourceRef: reqResourceRef{Name: reqName{Owner: owner, Module: moduleName, Label: revision}}, + IncludeSourceCodeInfo: true, + }) + cli.NoError(err, "Failed to marshal Connect request for %s/%s", owner, moduleName) + + connectURL := fmt.Sprintf("https://%s/buf.registry.module.v1.FileDescriptorSetService/GetFileDescriptorSet", host) + ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) + defer cancel() + req, err := http.NewRequestWithContext(ctx, http.MethodPost, connectURL, bytes.NewReader(reqBody)) + cli.NoError(err, "Failed to build request for %s/%s", owner, moduleName) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Connect-Protocol-Version", "1") + if authToken != "" { + req.Header.Set("Authorization", "Bearer "+authToken) + } + + resp, err := http.DefaultClient.Do(req) + cli.NoError(err, "HTTP request failed for %s/%s", owner, moduleName) + + body, err := io.ReadAll(resp.Body) + resp.Body.Close() + cli.NoError(err, "Failed to read response body for %s/%s", owner, moduleName) + cli.Ensure(resp.StatusCode == http.StatusOK, "BSR request for %s/%s returned HTTP %d: %s", owner, moduleName, resp.StatusCode, string(body)) + + var connectResp struct { + Commit struct { + ID string `json:"id"` + } `json:"commit"` + FileDescriptorSet json.RawMessage `json:"fileDescriptorSet"` } - return false + cli.NoError(json.Unmarshal(body, &connectResp), "Failed to parse Connect response for %s/%s", owner, moduleName) + + fds := &descriptorpb.FileDescriptorSet{} + cli.NoError(protojson.Unmarshal(connectResp.FileDescriptorSet, fds), "Failed to unmarshal FileDescriptorSet for %s/%s", owner, moduleName) + + return fds, connectResp.Commit.ID +} + +func buildBufRegistryPackageURL(module string, fullyQualifiedPackage string, commitID string) string { + // Example: https://buf.build/streamingfast/firehose-near/docs/d39e7444b0ba4b7685a06b6cdf65397b:sf.near.type.v1 + return fmt.Sprintf("https://%s/docs/%s:%s", module, commitID, fullyQualifiedPackage) } type ProtoFile struct { @@ -211,7 +258,7 @@ func templateFunctions() template.FuncMap { } func generateFilename(name string) string { - // Replace separators with dots: sf/ethereum/type/v2/block.proto -> sf.ethereum.type.v2.block.proto + // sf/ethereum/type/v2/block.proto -> sf.ethereum.type.v2.block.proto return strings.ReplaceAll(name, "/", ".") } @@ -219,6 +266,5 @@ func derefPtr[T any](in *T, orValue T) T { if in == nil { return orValue } - return *in } diff --git a/proto/wkp/core.Discover.proto.go b/proto/wkp/core.Discover.proto.go index e47a5ced..a904fbc5 100644 --- a/proto/wkp/core.Discover.proto.go +++ b/proto/wkp/core.Discover.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-tron/docs/55d8eaba13194171b3390f83bf8088d0:protocol register("core/Discover.proto", &WellKnownProto{ - FileDescriptor: "ChNjb3JlL0Rpc2NvdmVyLnByb3RvEghwcm90b2NvbCJQCghFbmRwb2ludBIYCgdhZGRyZXNzGAEgASgMUgdhZGRyZXNzEhIKBHBvcnQYAiABKAVSBHBvcnQSFgoGbm9kZUlkGAMgASgMUgZub2RlSWQikQEKC1BpbmdNZXNzYWdlEiYKBGZyb20YASABKAsyEi5wcm90b2NvbC5FbmRwb2ludFIEZnJvbRIiCgJ0bxgCIAEoCzISLnByb3RvY29sLkVuZHBvaW50UgJ0bxIYCgd2ZXJzaW9uGAMgASgFUgd2ZXJzaW9uEhwKCXRpbWVzdGFtcBgEIAEoA1IJdGltZXN0YW1wImcKC1BvbmdNZXNzYWdlEiYKBGZyb20YASABKAsyEi5wcm90b2NvbC5FbmRwb2ludFIEZnJvbRISCgRlY2hvGAIgASgFUgRlY2hvEhwKCXRpbWVzdGFtcBgDIAEoA1IJdGltZXN0YW1wInIKDkZpbmROZWlnaGJvdXJzEiYKBGZyb20YASABKAsyEi5wcm90b2NvbC5FbmRwb2ludFIEZnJvbRIaCgh0YXJnZXRJZBgCIAEoDFIIdGFyZ2V0SWQSHAoJdGltZXN0YW1wGAMgASgDUgl0aW1lc3RhbXAihgEKCk5laWdoYm91cnMSJgoEZnJvbRgBIAEoCzISLnByb3RvY29sLkVuZHBvaW50UgRmcm9tEjIKCm5laWdoYm91cnMYAiADKAsyEi5wcm90b2NvbC5FbmRwb2ludFIKbmVpZ2hib3VycxIcCgl0aW1lc3RhbXAYAyABKANSCXRpbWVzdGFtcCI/Cg1CYWNrdXBNZXNzYWdlEhIKBGZsYWcYASABKAhSBGZsYWcSGgoIcHJpb3JpdHkYAiABKAVSCHByaW9yaXR5QlIKD29yZy50cm9uLnByb3Rvc0IIRGlzY292ZXJaNWdpdGh1Yi5jb20vc3RyZWFtaW5nZmFzdC90cm9uLXByb3RvY29sL3BiL2NvcmU7cGJ0cm9uYgZwcm90bzM=", + FileDescriptor: "ChNjb3JlL0Rpc2NvdmVyLnByb3RvEghwcm90b2NvbCJQCghFbmRwb2ludBIYCgdhZGRyZXNzGAEgASgMUgdhZGRyZXNzEhIKBHBvcnQYAiABKAVSBHBvcnQSFgoGbm9kZUlkGAMgASgMUgZub2RlSWQikQEKC1BpbmdNZXNzYWdlEiYKBGZyb20YASABKAsyEi5wcm90b2NvbC5FbmRwb2ludFIEZnJvbRIiCgJ0bxgCIAEoCzISLnByb3RvY29sLkVuZHBvaW50UgJ0bxIYCgd2ZXJzaW9uGAMgASgFUgd2ZXJzaW9uEhwKCXRpbWVzdGFtcBgEIAEoA1IJdGltZXN0YW1wImcKC1BvbmdNZXNzYWdlEiYKBGZyb20YASABKAsyEi5wcm90b2NvbC5FbmRwb2ludFIEZnJvbRISCgRlY2hvGAIgASgFUgRlY2hvEhwKCXRpbWVzdGFtcBgDIAEoA1IJdGltZXN0YW1wInIKDkZpbmROZWlnaGJvdXJzEiYKBGZyb20YASABKAsyEi5wcm90b2NvbC5FbmRwb2ludFIEZnJvbRIaCgh0YXJnZXRJZBgCIAEoDFIIdGFyZ2V0SWQSHAoJdGltZXN0YW1wGAMgASgDUgl0aW1lc3RhbXAihgEKCk5laWdoYm91cnMSJgoEZnJvbRgBIAEoCzISLnByb3RvY29sLkVuZHBvaW50UgRmcm9tEjIKCm5laWdoYm91cnMYAiADKAsyEi5wcm90b2NvbC5FbmRwb2ludFIKbmVpZ2hib3VycxIcCgl0aW1lc3RhbXAYAyABKANSCXRpbWVzdGFtcCI/Cg1CYWNrdXBNZXNzYWdlEhIKBGZsYWcYASABKAhSBGZsYWcSGgoIcHJpb3JpdHkYAiABKAVSCHByaW9yaXR5QlIKD29yZy50cm9uLnByb3Rvc0IIRGlzY292ZXJaNWdpdGh1Yi5jb20vc3RyZWFtaW5nZmFzdC90cm9uLXByb3RvY29sL3BiL2NvcmU7cGJ0cm9uSsgKCgYSBAAAKwEKCAoBDBIDAAASCggKAQISAwIAEQoICgEIEgMFACgKRwoCCAESAwUAKCI8U3BlY2lmeSB0aGUgbmFtZSBvZiB0aGUgcGFja2FnZSB0aGF0IGdlbmVyYXRlZCB0aGUgSmF2YSBmaWxlCggKAQgSAwYAKQo8CgIICBIDBgApIjFTcGVjaWZ5IHRoZSBjbGFzcyBuYW1lIG9mIHRoZSBnZW5lcmF0ZWQgSmF2YSBmaWxlCggKAQgSAwcATAoJCgIICxIDBwBMCgoKAgQAEgQJAA0BCgoKAwQAARIDCQgQCgwKBQQAAgAFEgMKAgcKCwoEBAACABIDCgIUCgwKBQQAAgABEgMKCA8KDAoFBAACAAMSAwoSEwoMCgUEAAIBBRIDCwIHCgsKBAQAAgESAwsCEQoMCgUEAAIBARIDCwgMCgwKBQQAAgEDEgMLDxAKDAoFBAACAgUSAwwCBwoLCgQEAAICEgMMAhMKDAoFBAACAgESAwwIDgoMCgUEAAICAxIDDBESCgoKAgQBEgQPABQBCgoKAwQBARIDDwgTCgwKBQQBAgAGEgMQAgoKCwoEBAECABIDEAIUCgwKBQQBAgABEgMQCw8KDAoFBAECAAMSAxASEwoMCgUEAQIBBhIDEQIKCgsKBAQBAgESAxECEgoMCgUEAQIBARIDEQsNCgwKBQQBAgEDEgMREBEKDAoFBAECAgUSAxICBwoLCgQEAQICEgMSAhQKDAoFBAECAgESAxIIDwoMCgUEAQICAxIDEhITCgwKBQQBAgMFEgMTAgcKCwoEBAECAxIDEwIWCgwKBQQBAgMBEgMTCBEKDAoFBAECAwMSAxMUFQoKCgIEAhIEFgAaAQoKCgMEAgESAxYIEwoMCgUEAgIABhIDFwIKCgsKBAQCAgASAxcCFAoMCgUEAgIAARIDFwsPCgwKBQQCAgADEgMXEhMKDAoFBAICAQUSAxgCBwoLCgQEAgIBEgMYAhEKDAoFBAICAQESAxgIDAoMCgUEAgIBAxIDGA8QCgwKBQQCAgIFEgMZAgcKCwoEBAICAhIDGQIWCgwKBQQCAgIBEgMZCBEKDAoFBAICAgMSAxkUFQoKCgIEAxIEHAAgAQoKCgMEAwESAxwIFgoMCgUEAwIABhIDHQIKCgsKBAQDAgASAx0CFAoMCgUEAwIAARIDHQsPCgwKBQQDAgADEgMdEhMKDAoFBAMCAQUSAx4CBwoLCgQEAwIBEgMeAhUKDAoFBAMCAQESAx4IEAoMCgUEAwIBAxIDHhMUCgwKBQQDAgIFEgMfAgcKCwoEBAMCAhIDHwIWCgwKBQQDAgIBEgMfCBEKDAoFBAMCAgMSAx8UFQoKCgIEBBIEIgAmAQoKCgMEBAESAyIIEgoMCgUEBAIABhIDIwIKCgsKBAQEAgASAyMCFAoMCgUEBAIAARIDIwsPCgwKBQQEAgADEgMjEhMKDAoFBAQCAQQSAyQCCgoLCgQEBAIBEgMkAiMKDAoFBAQCAQYSAyQLEwoMCgUEBAIBARIDJBQeCgwKBQQEAgEDEgMkISIKDAoFBAQCAgUSAyUCBwoLCgQEBAICEgMlAhYKDAoFBAQCAgESAyUIEQoMCgUEBAICAxIDJRQVCgoKAgQFEgQoACsBCgoKAwQFARIDKAgVCgwKBQQFAgAFEgMpAgYKCwoEBAUCABIDKQIQCgwKBQQFAgABEgMpBwsKDAoFBAUCAAMSAykODwoMCgUEBQIBBRIDKgIHCgsKBAQFAgESAyoCFQoMCgUEBQIBARIDKggQCgwKBQQFAgEDEgMqExRiBnByb3RvMw==", }) } \ No newline at end of file diff --git a/proto/wkp/core.Tron.proto.go b/proto/wkp/core.Tron.proto.go index 6ba38592..da2faf06 100644 --- a/proto/wkp/core.Tron.proto.go +++ b/proto/wkp/core.Tron.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-tron/docs/55d8eaba13194171b3390f83bf8088d0:protocol register("core/Tron.proto", &WellKnownProto{ - FileDescriptor: "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", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/core.common.proto.go b/proto/wkp/core.common.proto.go index 7b9cad2a..8781a991 100644 --- a/proto/wkp/core.common.proto.go +++ b/proto/wkp/core.common.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-tron/docs/55d8eaba13194171b3390f83bf8088d0:protocol register("core/common.proto", &WellKnownProto{ - FileDescriptor: "ChFjb3JlL2NvbW1vbi5wcm90bxIIcHJvdG9jb2wqOQoMUmVzb3VyY2VDb2RlEg0KCUJBTkRXSURUSBAAEgoKBkVORVJHWRABEg4KClRST05fUE9XRVIQAkJRChhvcmcudHJvbi5wcm90b3MuY29udHJhY3RaNWdpdGh1Yi5jb20vc3RyZWFtaW5nZmFzdC90cm9uLXByb3RvY29sL3BiL2NvcmU7cGJ0cm9uYgZwcm90bzM=", + FileDescriptor: "ChFjb3JlL2NvbW1vbi5wcm90bxIIcHJvdG9jb2wqOQoMUmVzb3VyY2VDb2RlEg0KCUJBTkRXSURUSBAAEgoKBkVORVJHWRABEg4KClRST05fUE9XRVIQAkJRChhvcmcudHJvbi5wcm90b3MuY29udHJhY3RaNWdpdGh1Yi5jb20vc3RyZWFtaW5nZmFzdC90cm9uLXByb3RvY29sL3BiL2NvcmU7cGJ0cm9uSvUCCgYSBAAADAEKCAoBDBIDAAASCggKAQISAwIAEQoICgEIEgMEADEKRwoCCAESAwQAMSI8U3BlY2lmeSB0aGUgbmFtZSBvZiB0aGUgcGFja2FnZSB0aGF0IGdlbmVyYXRlZCB0aGUgSmF2YSBmaWxlCggKAQgSAwYATApnCgIICxIDBgBMGlxvcHRpb24gamF2YV9vdXRlcl9jbGFzc25hbWUgPSAiY29tbW9uIjsgLy9TcGVjaWZ5IHRoZSBjbGFzcyBuYW1lIG9mIHRoZSBnZW5lcmF0ZWQgSmF2YSBmaWxlCgoKCgIFABIECAAMAQoKCgMFAAESAwgFEQoMCgUFAAIAARIDCQILCgsKBAUAAgASAwkCEwoMCgUFAAIAAhIDCQ4SCgwKBQUAAgEBEgMKAggKCwoEBQACARIDCgIQCgwKBQUAAgECEgMKCw8KDAoFBQACAgESAwsCDAoLCgQFAAICEgMLAhQKDAoFBQACAgISAwsPE2IGcHJvdG8z", }) } \ No newline at end of file diff --git a/proto/wkp/google.protobuf.any.proto.go b/proto/wkp/google.protobuf.any.proto.go index 9121077d..6b2c2fb6 100644 --- a/proto/wkp/google.protobuf.any.proto.go +++ b/proto/wkp/google.protobuf.any.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-tron/docs/55d8eaba13194171b3390f83bf8088d0:google.protobuf register("google/protobuf/any.proto", &WellKnownProto{ - FileDescriptor: "Chlnb29nbGUvcHJvdG9idWYvYW55LnByb3RvEg9nb29nbGUucHJvdG9idWYiNgoDQW55EhkKCHR5cGVfdXJsGAEgASgJUgd0eXBlVXJsEhQKBXZhbHVlGAIgASgMUgV2YWx1ZUJ2ChNjb20uZ29vZ2xlLnByb3RvYnVmQghBbnlQcm90b1ABWixnb29nbGUuZ29sYW5nLm9yZy9wcm90b2J1Zi90eXBlcy9rbm93bi9hbnlwYqICA0dQQqoCHkdvb2dsZS5Qcm90b2J1Zi5XZWxsS25vd25UeXBlc2IGcHJvdG8z", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/google.protobuf.duration.proto.go b/proto/wkp/google.protobuf.duration.proto.go index 189f3446..6d3cabf2 100644 --- a/proto/wkp/google.protobuf.duration.proto.go +++ b/proto/wkp/google.protobuf.duration.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-cosmos/docs/453eb75cabe64abcb4a559f47bcb7e9a:google.protobuf register("google/protobuf/duration.proto", &WellKnownProto{ - FileDescriptor: "Ch5nb29nbGUvcHJvdG9idWYvZHVyYXRpb24ucHJvdG8SD2dvb2dsZS5wcm90b2J1ZiI6CghEdXJhdGlvbhIYCgdzZWNvbmRzGAEgASgDUgdzZWNvbmRzEhQKBW5hbm9zGAIgASgFUgVuYW5vc0KDAQoTY29tLmdvb2dsZS5wcm90b2J1ZkINRHVyYXRpb25Qcm90b1ABWjFnb29nbGUuZ29sYW5nLm9yZy9wcm90b2J1Zi90eXBlcy9rbm93bi9kdXJhdGlvbnBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM=", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/google.protobuf.timestamp.proto.go b/proto/wkp/google.protobuf.timestamp.proto.go index 8e377fac..2b2f111a 100644 --- a/proto/wkp/google.protobuf.timestamp.proto.go +++ b/proto/wkp/google.protobuf.timestamp.proto.go @@ -2,8 +2,8 @@ package wkp func init() { - // https://buf.build/streamingfast/firehose-ethereum/docs/34da8f52c41b487987aadcadacd8d61f:google.protobuf + // https://buf.build/streamingfast/firehose-ethereum/docs/d39e7444b0ba4b7685a06b6cdf65397b:google.protobuf register("google/protobuf/timestamp.proto", &WellKnownProto{ - FileDescriptor: "Ch9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1wLnByb3RvEg9nb29nbGUucHJvdG9idWYiOwoJVGltZXN0YW1wEhgKB3NlY29uZHMYASABKANSB3NlY29uZHMSFAoFbmFub3MYAiABKAVSBW5hbm9zQoUBChNjb20uZ29vZ2xlLnByb3RvYnVmQg5UaW1lc3RhbXBQcm90b1ABWjJnb29nbGUuZ29sYW5nLm9yZy9wcm90b2J1Zi90eXBlcy9rbm93bi90aW1lc3RhbXBwYvgBAaICA0dQQqoCHkdvb2dsZS5Qcm90b2J1Zi5XZWxsS25vd25UeXBlc2IGcHJvdG8z", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.acme.type.v1.type.proto.go b/proto/wkp/sf.acme.type.v1.type.proto.go index 0e14ab9a..58e4c3da 100644 --- a/proto/wkp/sf.acme.type.v1.type.proto.go +++ b/proto/wkp/sf.acme.type.v1.type.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-acme/docs/ba0f30a18c4b464abd9a9fbd1559e613:sf.acme.type.v1 register("sf/acme/type/v1/type.proto", &WellKnownProto{ - FileDescriptor: "ChpzZi9hY21lL3R5cGUvdjEvdHlwZS5wcm90bxIPc2YuYWNtZS50eXBlLnYxIogCCgtCbG9ja0hlYWRlchIWCgZoZWlnaHQYASABKARSBmhlaWdodBISCgRoYXNoGAIgASgJUgRoYXNoEiYKDHByZXZpb3VzX251bRgDIAEoBEgAUgtwcmV2aW91c051bYgBARIoCg1wcmV2aW91c19oYXNoGAQgASgJSAFSDHByZXZpb3VzSGFzaIgBARIbCglmaW5hbF9udW0YBSABKARSCGZpbmFsTnVtEh0KCmZpbmFsX2hhc2gYBiABKAlSCWZpbmFsSGFzaBIcCgl0aW1lc3RhbXAYByABKANSCXRpbWVzdGFtcEIPCg1fcHJldmlvdXNfbnVtQhAKDl9wcmV2aW91c19oYXNoIn8KBUJsb2NrEjQKBmhlYWRlchgBIAEoCzIcLnNmLmFjbWUudHlwZS52MS5CbG9ja0hlYWRlclIGaGVhZGVyEkAKDHRyYW5zYWN0aW9ucxgCIAMoCzIcLnNmLmFjbWUudHlwZS52MS5UcmFuc2FjdGlvblIMdHJhbnNhY3Rpb25zIo8CCgtUcmFuc2FjdGlvbhISCgR0eXBlGAEgASgJUgR0eXBlEhIKBGhhc2gYAiABKAlSBGhhc2gSFgoGc2VuZGVyGAMgASgJUgZzZW5kZXISGgoIcmVjZWl2ZXIYBCABKAlSCHJlY2VpdmVyEi8KBmFtb3VudBgFIAEoCzIXLnNmLmFjbWUudHlwZS52MS5CaWdJbnRSBmFtb3VudBIpCgNmZWUYBiABKAsyFy5zZi5hY21lLnR5cGUudjEuQmlnSW50UgNmZWUSGAoHc3VjY2VzcxgHIAEoCFIHc3VjY2VzcxIuCgZldmVudHMYCCADKAsyFi5zZi5hY21lLnR5cGUudjEuRXZlbnRSBmV2ZW50cyJXCgVFdmVudBISCgR0eXBlGAEgASgJUgR0eXBlEjoKCmF0dHJpYnV0ZXMYAiADKAsyGi5zZi5hY21lLnR5cGUudjEuQXR0cmlidXRlUgphdHRyaWJ1dGVzIjMKCUF0dHJpYnV0ZRIQCgNrZXkYASABKAlSA2tleRIUCgV2YWx1ZRgCIAEoCVIFdmFsdWUiHgoGQmlnSW50EhQKBWJ5dGVzGAEgASgMUgVieXRlc0JCWkBnaXRodWIuY29tL3N0cmVhbWluZ2Zhc3QvZmlyZWhvc2UtYWNtZS9wYi9zZi9hY21lL3R5cGUvdjE7cGJhY21lYgZwcm90bzM=", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.antelope.type.v1.type.proto.go b/proto/wkp/sf.antelope.type.v1.type.proto.go index 3982d1f8..d9011c89 100644 --- a/proto/wkp/sf.antelope.type.v1.type.proto.go +++ b/proto/wkp/sf.antelope.type.v1.type.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/pinax/firehose-antelope/docs/8f4b4af935b343a28bfdce451f350810:sf.antelope.type.v1 register("sf/antelope/type/v1/type.proto", &WellKnownProto{ - FileDescriptor: "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", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.beacon.type.v1.type.proto.go b/proto/wkp/sf.beacon.type.v1.type.proto.go index 3a9c5730..6e8e8960 100644 --- a/proto/wkp/sf.beacon.type.v1.type.proto.go +++ b/proto/wkp/sf.beacon.type.v1.type.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/pinax/firehose-beacon/docs/4af4700eaa1848cca070a059060c27cb:sf.beacon.type.v1 register("sf/beacon/type/v1/type.proto", &WellKnownProto{ - FileDescriptor: "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", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.bitcoin.type.v1.type.proto.go b/proto/wkp/sf.bitcoin.type.v1.type.proto.go index 9464387f..cc8d47eb 100644 --- a/proto/wkp/sf.bitcoin.type.v1.type.proto.go +++ b/proto/wkp/sf.bitcoin.type.v1.type.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-bitcoin/docs/0d8ce32fe71441df82c89dcccda35366:sf.bitcoin.type.v1 register("sf/bitcoin/type/v1/type.proto", &WellKnownProto{ - FileDescriptor: "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", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.cosmos.type.v2.block.proto.go b/proto/wkp/sf.cosmos.type.v2.block.proto.go index 9c7a04d8..6e2b00ba 100644 --- a/proto/wkp/sf.cosmos.type.v2.block.proto.go +++ b/proto/wkp/sf.cosmos.type.v2.block.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-cosmos/docs/453eb75cabe64abcb4a559f47bcb7e9a:sf.cosmos.type.v2 register("sf/cosmos/type/v2/block.proto", &WellKnownProto{ - FileDescriptor: "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", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.ethereum.substreams.v1.rpc.proto.go b/proto/wkp/sf.ethereum.substreams.v1.rpc.proto.go index 68817c13..d9b53e98 100644 --- a/proto/wkp/sf.ethereum.substreams.v1.rpc.proto.go +++ b/proto/wkp/sf.ethereum.substreams.v1.rpc.proto.go @@ -2,8 +2,8 @@ package wkp func init() { - // https://buf.build/streamingfast/firehose-ethereum/docs/34da8f52c41b487987aadcadacd8d61f:sf.ethereum.substreams.v1 + // https://buf.build/streamingfast/firehose-ethereum/docs/d39e7444b0ba4b7685a06b6cdf65397b:sf.ethereum.substreams.v1 register("sf/ethereum/substreams/v1/rpc.proto", &WellKnownProto{ - FileDescriptor: "CiNzZi9ldGhlcmV1bS9zdWJzdHJlYW1zL3YxL3JwYy5wcm90bxIZc2YuZXRoZXJldW0uc3Vic3RyZWFtcy52MSJECghScGNDYWxscxI4CgVjYWxscxgBIAMoCzIiLnNmLmV0aGVyZXVtLnN1YnN0cmVhbXMudjEuUnBjQ2FsbFIFY2FsbHMiNgoHUnBjQ2FsbBIXCgd0b19hZGRyGAEgASgMUgZ0b0FkZHISEgoEZGF0YRgCIAEoDFIEZGF0YSJUCgxScGNSZXNwb25zZXMSRAoJcmVzcG9uc2VzGAEgAygLMiYuc2YuZXRoZXJldW0uc3Vic3RyZWFtcy52MS5ScGNSZXNwb25zZVIJcmVzcG9uc2VzIjcKC1JwY1Jlc3BvbnNlEhAKA3JhdxgBIAEoDFIDcmF3EhYKBmZhaWxlZBgCIAEoCFIGZmFpbGVkIkYKFFJwY0dldEJhbGFuY2VSZXF1ZXN0EhgKB2FkZHJlc3MYASABKAxSB2FkZHJlc3MSFAoFYmxvY2sYAiABKAlSBWJsb2NrIkkKFVJwY0dldEJhbGFuY2VSZXNwb25zZRIYCgdiYWxhbmNlGAEgASgMUgdiYWxhbmNlEhYKBmZhaWxlZBgCIAEoCFIGZmFpbGVkImQKFVJwY0dldEJhbGFuY2VSZXF1ZXN0cxJLCghyZXF1ZXN0cxgBIAMoCzIvLnNmLmV0aGVyZXVtLnN1YnN0cmVhbXMudjEuUnBjR2V0QmFsYW5jZVJlcXVlc3RSCHJlcXVlc3RzImgKFlJwY0dldEJhbGFuY2VSZXNwb25zZXMSTgoJcmVzcG9uc2VzGAEgAygLMjAuc2YuZXRoZXJldW0uc3Vic3RyZWFtcy52MS5ScGNHZXRCYWxhbmNlUmVzcG9uc2VSCXJlc3BvbnNlc0JXWlVnaXRodWIuY29tL3N0cmVhbWluZ2Zhc3QvZmlyZWhvc2UtZXRoZXJldW0vdHlwZXMvcGIvc2YvZXRoZXJldW0vc3Vic3RyZWFtcy92MTtwYmV0aHNzYgZwcm90bzM=", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.ethereum.transform.v1.transforms.proto.go b/proto/wkp/sf.ethereum.transform.v1.transforms.proto.go index 34a432c6..efddc28e 100644 --- a/proto/wkp/sf.ethereum.transform.v1.transforms.proto.go +++ b/proto/wkp/sf.ethereum.transform.v1.transforms.proto.go @@ -2,8 +2,8 @@ package wkp func init() { - // https://buf.build/streamingfast/firehose-ethereum/docs/34da8f52c41b487987aadcadacd8d61f:sf.ethereum.transform.v1 + // https://buf.build/streamingfast/firehose-ethereum/docs/d39e7444b0ba4b7685a06b6cdf65397b:sf.ethereum.transform.v1 register("sf/ethereum/transform/v1/transforms.proto", &WellKnownProto{ - FileDescriptor: "CilzZi9ldGhlcmV1bS90cmFuc2Zvcm0vdjEvdHJhbnNmb3Jtcy5wcm90bxIYc2YuZXRoZXJldW0udHJhbnNmb3JtLnYxItYBCg5Db21iaW5lZEZpbHRlchJECgtsb2dfZmlsdGVycxgBIAMoCzIjLnNmLmV0aGVyZXVtLnRyYW5zZm9ybS52MS5Mb2dGaWx0ZXJSCmxvZ0ZpbHRlcnMSSQoMY2FsbF9maWx0ZXJzGAIgAygLMiYuc2YuZXRoZXJldW0udHJhbnNmb3JtLnYxLkNhbGxUb0ZpbHRlclILY2FsbEZpbHRlcnMSMwoWc2VuZF9hbGxfYmxvY2tfaGVhZGVycxgDIAEoCFITc2VuZEFsbEJsb2NrSGVhZGVycyJWCg5NdWx0aUxvZ0ZpbHRlchJECgtsb2dfZmlsdGVycxgBIAMoCzIjLnNmLmV0aGVyZXVtLnRyYW5zZm9ybS52MS5Mb2dGaWx0ZXJSCmxvZ0ZpbHRlcnMiVAoJTG9nRmlsdGVyEhwKCWFkZHJlc3NlcxgBIAMoDFIJYWRkcmVzc2VzEikKEGV2ZW50X3NpZ25hdHVyZXMYAiADKAxSD2V2ZW50U2lnbmF0dXJlcyJeChFNdWx0aUNhbGxUb0ZpbHRlchJJCgxjYWxsX2ZpbHRlcnMYASADKAsyJi5zZi5ldGhlcmV1bS50cmFuc2Zvcm0udjEuQ2FsbFRvRmlsdGVyUgtjYWxsRmlsdGVycyJMCgxDYWxsVG9GaWx0ZXISHAoJYWRkcmVzc2VzGAEgAygMUglhZGRyZXNzZXMSHgoKc2lnbmF0dXJlcxgCIAMoDFIKc2lnbmF0dXJlcyIMCgpIZWFkZXJPbmx5QlpaWGdpdGh1Yi5jb20vc3RyZWFtaW5nZmFzdC9maXJlaG9zZS1ldGhlcmV1bS90eXBlcy9wYi9zZi9ldGhlcmV1bS90cmFuc2Zvcm0vdjE7cGJ0cmFuc2Zvcm1iBnByb3RvMw==", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.ethereum.type.v2.type.proto.go b/proto/wkp/sf.ethereum.type.v2.type.proto.go index b3e71981..347b9201 100644 --- a/proto/wkp/sf.ethereum.type.v2.type.proto.go +++ b/proto/wkp/sf.ethereum.type.v2.type.proto.go @@ -2,8 +2,8 @@ package wkp func init() { - // https://buf.build/streamingfast/firehose-ethereum/docs/34da8f52c41b487987aadcadacd8d61f:sf.ethereum.type.v2 + // https://buf.build/streamingfast/firehose-ethereum/docs/d39e7444b0ba4b7685a06b6cdf65397b:sf.ethereum.type.v2 register("sf/ethereum/type/v2/type.proto", &WellKnownProto{ - FileDescriptor: "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", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.near.transform.v1.transform.proto.go b/proto/wkp/sf.near.transform.v1.transform.proto.go index eda40020..17f1509e 100644 --- a/proto/wkp/sf.near.transform.v1.transform.proto.go +++ b/proto/wkp/sf.near.transform.v1.transform.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-near/docs/0b7e4efe1b9f447495fdfb54b7a6880f:sf.near.transform.v1 register("sf/near/transform/v1/transform.proto", &WellKnownProto{ - FileDescriptor: "CiRzZi9uZWFyL3RyYW5zZm9ybS92MS90cmFuc2Zvcm0ucHJvdG8SFHNmLm5lYXIudHJhbnNmb3JtLnYxIo8BChJCYXNpY1JlY2VpcHRGaWx0ZXISGgoIYWNjb3VudHMYASADKAlSCGFjY291bnRzEl0KF3ByZWZpeF9hbmRfc3VmZml4X3BhaXJzGAIgAygLMiYuc2YubmVhci50cmFuc2Zvcm0udjEuUHJlZml4U3VmZml4UGFpclIUcHJlZml4QW5kU3VmZml4UGFpcnMiQgoQUHJlZml4U3VmZml4UGFpchIWCgZwcmVmaXgYASABKAlSBnByZWZpeBIWCgZzdWZmaXgYAiABKAlSBnN1ZmZpeCIMCgpIZWFkZXJPbmx5QkxaSmdpdGh1Yi5jb20vc3RyZWFtaW5nZmFzdC9maXJlaG9zZS1uZWFyL3BiL3NmL25lYXIvdHJhbnNmb3JtL3YxO3BidHJhbnNmb3JtYgZwcm90bzM=", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.near.type.v1.type.proto.go b/proto/wkp/sf.near.type.v1.type.proto.go index a5026b7a..518191d9 100644 --- a/proto/wkp/sf.near.type.v1.type.proto.go +++ b/proto/wkp/sf.near.type.v1.type.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-near/docs/0b7e4efe1b9f447495fdfb54b7a6880f:sf.near.type.v1 register("sf/near/type/v1/type.proto", &WellKnownProto{ - FileDescriptor: "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", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.solana.type.v1.account.proto.go b/proto/wkp/sf.solana.type.v1.account.proto.go index 285fde26..dd821899 100644 --- a/proto/wkp/sf.solana.type.v1.account.proto.go +++ b/proto/wkp/sf.solana.type.v1.account.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-solana/docs/807d91ba112044979b44a0f65574784f:sf.solana.type.v1 register("sf/solana/type/v1/account.proto", &WellKnownProto{ - FileDescriptor: "Ch9zZi9zb2xhbmEvdHlwZS92MS9hY2NvdW50LnByb3RvEhFzZi5zb2xhbmEudHlwZS52MRofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90byLqAQoMQWNjb3VudEJsb2NrEhIKBHNsb3QYASABKARSBHNsb3QSEgoEaGFzaBgCIAEoCVIEaGFzaBIfCgtwYXJlbnRfc2xvdBgDIAEoBFIKcGFyZW50U2xvdBIfCgtwYXJlbnRfaGFzaBgEIAEoCVIKcGFyZW50SGFzaBI4Cgl0aW1lc3RhbXAYBiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgl0aW1lc3RhbXASNgoIYWNjb3VudHMYByADKAsyGi5zZi5zb2xhbmEudHlwZS52MS5BY2NvdW50UghhY2NvdW50cyJnCgdBY2NvdW50EhgKB2FkZHJlc3MYASABKAxSB2FkZHJlc3MSFAoFb3duZXIYAiABKAxSBW93bmVyEhIKBGRhdGEYAyABKAxSBGRhdGESGAoHZGVsZXRlZBgHIAEoCFIHZGVsZXRlZEJFWkNnaXRodWIuY29tL3N0cmVhbWluZ2Zhc3QvZmlyZWhvc2Utc29sYW5hL3BiL3NmL3NvbGFuYS90eXBlL3YxO3Bic29sYgZwcm90bzM=", + FileDescriptor: "Ch9zZi9zb2xhbmEvdHlwZS92MS9hY2NvdW50LnByb3RvEhFzZi5zb2xhbmEudHlwZS52MRofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90byLqAQoMQWNjb3VudEJsb2NrEhIKBHNsb3QYASABKARSBHNsb3QSEgoEaGFzaBgCIAEoCVIEaGFzaBIfCgtwYXJlbnRfc2xvdBgDIAEoBFIKcGFyZW50U2xvdBIfCgtwYXJlbnRfaGFzaBgEIAEoCVIKcGFyZW50SGFzaBI4Cgl0aW1lc3RhbXAYBiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgl0aW1lc3RhbXASNgoIYWNjb3VudHMYByADKAsyGi5zZi5zb2xhbmEudHlwZS52MS5BY2NvdW50UghhY2NvdW50cyJnCgdBY2NvdW50EhgKB2FkZHJlc3MYASABKAxSB2FkZHJlc3MSFAoFb3duZXIYAiABKAxSBW93bmVyEhIKBGRhdGEYAyABKAxSBGRhdGESGAoHZGVsZXRlZBgHIAEoCFIHZGVsZXRlZEJFWkNnaXRodWIuY29tL3N0cmVhbWluZ2Zhc3QvZmlyZWhvc2Utc29sYW5hL3BiL3NmL3NvbGFuYS90eXBlL3YxO3Bic29sSqAFCgYSBAAAFgEKCAoBDBIDAAASCggKAQgSAwIAWgoJCgIICxIDAgBaCggKAQISAwQAGgoJCgIDABIDBgApCgoKAgQAEgQIAA8BCgoKAwQAARIDCAgUCgwKBQQAAgAFEgMJAggKCwoEBAACABIDCQISCgwKBQQAAgABEgMJCQ0KDAoFBAACAAMSAwkQEQoMCgUEAAIBBRIDCgIICgsKBAQAAgESAwoCEgoMCgUEAAIBARIDCgkNCgwKBQQAAgEDEgMKEBEKDAoFBAACAgUSAwsCCAoLCgQEAAICEgMLAhkKDAoFBAACAgESAwsJFAoMCgUEAAICAxIDCxcYCgwKBQQAAgMFEgMMAggKCwoEBAACAxIDDAIZCgwKBQQAAgMBEgMMCRQKDAoFBAACAwMSAwwXGAoMCgUEAAIEBhIDDQIbCgsKBAQAAgQSAw0CKgoMCgUEAAIEARIDDRwlCgwKBQQAAgQDEgMNKCkKDAoFBAACBQQSAw4CCgoLCgQEAAIFEgMOAiAKDAoFBAACBQYSAw4LEgoMCgUEAAIFARIDDhMbCgwKBQQAAgUDEgMOHh8KCgoCBAESBBEAFgEKCgoDBAEBEgMRCA8KDAoFBAECAAUSAxICBwoLCgQEAQIAEgMSAhQKDAoFBAECAAESAxIIDwoMCgUEAQIAAxIDEhITCgwKBQQBAgEFEgMTAgcKCwoEBAECARIDEwISCgwKBQQBAgEBEgMTCA0KDAoFBAECAQMSAxMQEQoMCgUEAQICBRIDFAIHCgsKBAQBAgISAxQCEQoMCgUEAQICARIDFAgMCgwKBQQBAgIDEgMUDxAKDAoFBAECAwUSAxUCBgoLCgQEAQIDEgMVAhMKDAoFBAECAwESAxUHDgoMCgUEAQIDAxIDFRESYgZwcm90bzM=", }) } \ No newline at end of file diff --git a/proto/wkp/sf.solana.type.v1.type.proto.go b/proto/wkp/sf.solana.type.v1.type.proto.go index 7c7c2f0a..3354157f 100644 --- a/proto/wkp/sf.solana.type.v1.type.proto.go +++ b/proto/wkp/sf.solana.type.v1.type.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-solana/docs/807d91ba112044979b44a0f65574784f:sf.solana.type.v1 register("sf/solana/type/v1/type.proto", &WellKnownProto{ - FileDescriptor: "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", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.stellar.type.v1.block.proto.go b/proto/wkp/sf.stellar.type.v1.block.proto.go index d3f80ce5..7dfb1957 100644 --- a/proto/wkp/sf.stellar.type.v1.block.proto.go +++ b/proto/wkp/sf.stellar.type.v1.block.proto.go @@ -2,8 +2,8 @@ package wkp func init() { - // https://buf.build/streamingfast/firehose-stellar/docs/f740dc7b76984a479446c507d3ccd824:sf.stellar.type.v1 + // https://buf.build/streamingfast/firehose-stellar/docs/1a5125f9e66b4161a0ff5604a36392a6:sf.stellar.type.v1 register("sf/stellar/type/v1/block.proto", &WellKnownProto{ - FileDescriptor: "Ch5zZi9zdGVsbGFyL3R5cGUvdjEvYmxvY2sucHJvdG8SEnNmLnN0ZWxsYXIudHlwZS52MRofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90byKBAgoFQmxvY2sSFgoGbnVtYmVyGAEgASgEUgZudW1iZXISEgoEaGFzaBgCIAEoDFIEaGFzaBIyCgZoZWFkZXIYAyABKAsyGi5zZi5zdGVsbGFyLnR5cGUudjEuSGVhZGVyUgZoZWFkZXISGAoHdmVyc2lvbhgEIAEoA1IHdmVyc2lvbhJDCgx0cmFuc2FjdGlvbnMYBiADKAsyHy5zZi5zdGVsbGFyLnR5cGUudjEuVHJhbnNhY3Rpb25SDHRyYW5zYWN0aW9ucxI5CgpjcmVhdGVkX2F0GAkgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJY3JlYXRlZEF0IsABCgZIZWFkZXISJQoObGVkZ2VyX3ZlcnNpb24YASABKA1SDWxlZGdlclZlcnNpb24SMAoUcHJldmlvdXNfbGVkZ2VyX2hhc2gYAiABKAxSEnByZXZpb3VzTGVkZ2VySGFzaBIfCgt0b3RhbF9jb2lucxgDIAEoA1IKdG90YWxDb2lucxIZCghiYXNlX2ZlZRgEIAEoDVIHYmFzZUZlZRIhCgxiYXNlX3Jlc2VydmUYBSABKA1SC2Jhc2VSZXNlcnZlIr4CCgtUcmFuc2FjdGlvbhISCgRoYXNoGAEgASgMUgRoYXNoEj0KBnN0YXR1cxgCIAEoDjIlLnNmLnN0ZWxsYXIudHlwZS52MS5UcmFuc2FjdGlvblN0YXR1c1IGc3RhdHVzEjkKCmNyZWF0ZWRfYXQYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgljcmVhdGVkQXQSKwoRYXBwbGljYXRpb25fb3JkZXIYBSABKARSEGFwcGxpY2F0aW9uT3JkZXISIQoMZW52ZWxvcGVfeGRyGAYgASgMUgtlbnZlbG9wZVhkchIdCgpyZXN1bHRfeGRyGAggASgMUglyZXN1bHRYZHISMgoGZXZlbnRzGAkgASgLMhouc2Yuc3RlbGxhci50eXBlLnYxLkV2ZW50c1IGZXZlbnRzIsUBCgZFdmVudHMSMgoVZGlhZ25vc3RpY19ldmVudHNfeGRyGAEgAygMUhNkaWFnbm9zdGljRXZlbnRzWGRyEjQKFnRyYW5zYWN0aW9uX2V2ZW50c194ZHIYAiADKAxSFHRyYW5zYWN0aW9uRXZlbnRzWGRyElEKE2NvbnRyYWN0X2V2ZW50c194ZHIYAyADKAsyIS5zZi5zdGVsbGFyLnR5cGUudjEuQ29udHJhY3RFdmVudFIRY29udHJhY3RFdmVudHNYZHIiJwoNQ29udHJhY3RFdmVudBIWCgZldmVudHMYASADKAxSBmV2ZW50cyo5ChFUcmFuc2FjdGlvblN0YXR1cxILCgdVTktOT1dOEAASCwoHU1VDQ0VTUxABEgoKBkZBSUxFRBACQktaSWdpdGh1Yi5jb20vc3RyZWFtaW5nZmFzdC9maXJlaG9zZS1zdGVsbGFyL3BiL3NmL3N0ZWxsYXIvdHlwZS92MTtwYnN0ZWxsYXJiBnByb3RvMw==", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/proto/wkp/sf.tron.type.v1.block.proto.go b/proto/wkp/sf.tron.type.v1.block.proto.go index b13d7730..6e115b1b 100644 --- a/proto/wkp/sf.tron.type.v1.block.proto.go +++ b/proto/wkp/sf.tron.type.v1.block.proto.go @@ -4,6 +4,6 @@ package wkp func init() { // https://buf.build/streamingfast/firehose-tron/docs/55d8eaba13194171b3390f83bf8088d0:sf.tron.type.v1 register("sf/tron/type/v1/block.proto", &WellKnownProto{ - FileDescriptor: "ChtzZi90cm9uL3R5cGUvdjEvYmxvY2sucHJvdG8SD3NmLnRyb24udHlwZS52MRoZZ29vZ2xlL3Byb3RvYnVmL2FueS5wcm90bxoPY29yZS9Ucm9uLnByb3RvIo8BCgVCbG9jaxIOCgJpZBgBIAEoDFICaWQSNAoGaGVhZGVyGAIgASgLMhwuc2YudHJvbi50eXBlLnYxLkJsb2NrSGVhZGVyUgZoZWFkZXISQAoMdHJhbnNhY3Rpb25zGAMgAygLMhwuc2YudHJvbi50eXBlLnYxLlRyYW5zYWN0aW9uUgx0cmFuc2FjdGlvbnMimwIKC0Jsb2NrSGVhZGVyEhYKBm51bWJlchgBIAEoBFIGbnVtYmVyEiAKDHR4X3RyaWVfcm9vdBgCIAEoDFIKdHhUcmllUm9vdBInCg93aXRuZXNzX2FkZHJlc3MYAyABKAxSDndpdG5lc3NBZGRyZXNzEiMKDXBhcmVudF9udW1iZXIYBCABKARSDHBhcmVudE51bWJlchIfCgtwYXJlbnRfaGFzaBgFIAEoDFIKcGFyZW50SGFzaBIYCgd2ZXJzaW9uGAYgASgNUgd2ZXJzaW9uEhwKCXRpbWVzdGFtcBgHIAEoA1IJdGltZXN0YW1wEisKEXdpdG5lc3Nfc2lnbmF0dXJlGAggASgMUhB3aXRuZXNzU2lnbmF0dXJlIo4ECgtUcmFuc2FjdGlvbhISCgR0eGlkGAEgASgMUgR0eGlkEhwKCXNpZ25hdHVyZRgCIAMoDFIJc2lnbmF0dXJlEiYKD3JlZl9ibG9ja19ieXRlcxgDIAEoDFINcmVmQmxvY2tCeXRlcxIkCg5yZWZfYmxvY2tfaGFzaBgEIAEoDFIMcmVmQmxvY2tIYXNoEh4KCmV4cGlyYXRpb24YBSABKANSCmV4cGlyYXRpb24SHAoJdGltZXN0YW1wGAYgASgDUgl0aW1lc3RhbXASJwoPY29udHJhY3RfcmVzdWx0GAcgAygMUg5jb250cmFjdFJlc3VsdBIWCgZyZXN1bHQYCCABKAhSBnJlc3VsdBIxCgRjb2RlGAkgASgOMh0uc2YudHJvbi50eXBlLnYxLlJlc3BvbnNlQ29kZVIEY29kZRIYCgdtZXNzYWdlGAogASgMUgdtZXNzYWdlEh8KC2VuZXJneV91c2VkGAsgASgDUgplbmVyZ3lVc2VkEiUKDmVuZXJneV9wZW5hbHR5GAwgASgDUg1lbmVyZ3lQZW5hbHR5Ei0KBGluZm8YDSABKAsyGS5wcm90b2NvbC5UcmFuc2FjdGlvbkluZm9SBGluZm8SPAoJY29udHJhY3RzGA4gAygLMh4ucHJvdG9jb2wuVHJhbnNhY3Rpb24uQ29udHJhY3RSCWNvbnRyYWN0cyrRAgoMUmVzcG9uc2VDb2RlEgsKB1NVQ0NFU1MQABIMCghTSUdFUlJPUhABEhsKF0NPTlRSQUNUX1ZBTElEQVRFX0VSUk9SEAISFgoSQ09OVFJBQ1RfRVhFX0VSUk9SEAMSEgoOQkFORFdJVEhfRVJST1IQBBIZChVEVVBfVFJBTlNBQ1RJT05fRVJST1IQBRIPCgtUQVBPU19FUlJPUhAGEh0KGVRPT19CSUdfVFJBTlNBQ1RJT05fRVJST1IQBxIgChxUUkFOU0FDVElPTl9FWFBJUkFUSU9OX0VSUk9SEAgSDwoLU0VSVkVSX0JVU1kQCRIRCg1OT19DT05ORUNUSU9OEAoSIwofTk9UX0VOT1VHSF9FRkZFQ1RJVkVfQ09OTkVDVElPThALEhYKEkJMT0NLX1VOU09MSURJRklFRBAMEg8KC09USEVSX0VSUk9SEBRCQlpAZ2l0aHViLmNvbS9zdHJlYW1pbmdmYXN0L2ZpcmVob3NlLXRyb24vcGIvc2YvdHJvbi90eXBlL3YxO3BidHJvbmIGcHJvdG8z", + FileDescriptor: "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", }) } \ No newline at end of file diff --git a/relayer/relayer_e2e_test.go b/relayer/relayer_e2e_test.go index a45480f6..b1574b65 100644 --- a/relayer/relayer_e2e_test.go +++ b/relayer/relayer_e2e_test.go @@ -23,8 +23,11 @@ import ( "testing" "time" - dockercontainer "github.com/docker/docker/api/types/container" + "net/netip" + "github.com/docker/go-connections/nat" + dockercontainer "github.com/moby/moby/api/types/container" + dockernetwork "github.com/moby/moby/api/types/network" "github.com/streamingfast/bstream" pbbstream "github.com/streamingfast/bstream/pb/sf/bstream/v1" "github.com/streamingfast/dgrpc" @@ -302,9 +305,9 @@ func startReaderNodeContainer(t *testing.T, ctx context.Context, tmpDir string, ExposedPorts: []string{string(containerPort)}, HostConfigModifier: func(hc *dockercontainer.HostConfig) { // Fix the host-side binding so stop+start reuses the same port. - hc.PortBindings = nat.PortMap{ - containerPort: []nat.PortBinding{ - {HostIP: "127.0.0.1", HostPort: fmt.Sprintf("%d", readerHostPort)}, + hc.PortBindings = dockernetwork.PortMap{ + dockernetwork.MustParsePort(string(containerPort)): []dockernetwork.PortBinding{ + {HostIP: netip.MustParseAddr("127.0.0.1"), HostPort: fmt.Sprintf("%d", readerHostPort)}, }, } hc.Binds = []string{ @@ -315,7 +318,7 @@ func startReaderNodeContainer(t *testing.T, ctx context.Context, tmpDir string, } }, WaitingFor: wait.ForAll( - wait.ForListeningPort(containerPort), + wait.ForListeningPort(string(containerPort)), wait.ForLog("serving gRPC").WithStartupTimeout(30*time.Second), ), }