Upgrade to Avalanche 1.9.0 - added missing files

Author: mboben

avalanchego/SECURITY.md

@@ -0,0 +1,17 @@
+# Security Policy
+
+Avalanche takes the security of the platform and of its users very seriously. We and our community recognize the critical role of external security researchers and developers and welcome responsible disclosures. Valid reports will be eligible for a reward (terms and conditions apply).
+
+## Reporting a Vulnerability
+
+**Please do not file a public ticket** mentioning the vulnerability. To disclose a vulnerability submit it through our [Bug Bounty Program](https://hackenproof.com/avalanche).
+
+Vulnerabilities must be disclosed to us privately with reasonable time to respond, and avoid compromise of other users and accounts, or loss of funds that are not your own. We do not reward spam or social engineering vulnerabilities. 
+
+Do not test for or validate any security issues in the live Avalanche networks (Mainnet and Fuji testnet), confirm all exploits in a local private testnet.
+
+Please refer to the [Bug Bounty Page](https://hackenproof.com/avalanche) for the most up-to-date program rules and scope.
+
+## Supported Versions
+
+Please use the [most recently released version](https://github.com/ava-labs/avalanchego/releases/latest) to perform testing and to validate security issues.

avalanchego/api/info/client_test.go

@@ -0,0 +1,71 @@
+// Copyright (C) 2019-2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package info
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/utils/rpc"
+)
+
+type mockClient struct {
+	reply  IsBootstrappedResponse
+	err    error
+	onCall func()
+}
+
+func (mc *mockClient) SendRequest(_ context.Context, _ string, _ interface{}, replyIntf interface{}, _ ...rpc.Option) error {
+	reply := replyIntf.(*IsBootstrappedResponse)
+	*reply = mc.reply
+	mc.onCall()
+	return mc.err
+}
+
+func TestNewClient(t *testing.T) {
+	require := require.New(t)
+
+	c := NewClient("")
+	require.NotNil(c)
+}
+
+func TestClient(t *testing.T) {
+	require := require.New(t)
+
+	mc := &mockClient{
+		reply:  IsBootstrappedResponse{true},
+		err:    nil,
+		onCall: func() {},
+	}
+	c := &client{
+		requester: mc,
+	}
+
+	{
+		bootstrapped, err := c.IsBootstrapped(context.Background(), "X")
+		require.NoError(err)
+		require.True(bootstrapped)
+	}
+
+	mc.reply.IsBootstrapped = false
+
+	{
+		bootstrapped, err := c.IsBootstrapped(context.Background(), "X")
+		require.NoError(err)
+		require.False(bootstrapped)
+	}
+
+	mc.onCall = func() {
+		mc.reply.IsBootstrapped = true
+	}
+
+	{
+		bootstrapped, err := AwaitBootstrapped(context.Background(), c, "X", time.Microsecond)
+		require.NoError(err)
+		require.True(bootstrapped)
+	}
+}

avalanchego/api/server/metrics.go

@@ -0,0 +1,74 @@
+// Copyright (C) 2019-2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package server
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+
+	"github.com/ava-labs/avalanchego/utils/wrappers"
+)
+
+type metrics struct {
+	numProcessing *prometheus.GaugeVec
+	numCalls      *prometheus.CounterVec
+	totalDuration *prometheus.GaugeVec
+}
+
+func newMetrics(namespace string, registerer prometheus.Registerer) (*metrics, error) {
+	m := &metrics{
+		numProcessing: prometheus.NewGaugeVec(
+			prometheus.GaugeOpts{
+				Namespace: namespace,
+				Name:      "calls_processing",
+				Help:      "The number of calls this API is currently processing",
+			},
+			[]string{"base"},
+		),
+		numCalls: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Namespace: namespace,
+				Name:      "calls",
+				Help:      "The number of calls this API has processed",
+			},
+			[]string{"base"},
+		),
+		totalDuration: prometheus.NewGaugeVec(
+			prometheus.GaugeOpts{
+				Namespace: namespace,
+				Name:      "calls_duration",
+				Help:      "The total amount of time, in nanoseconds, spent handling API calls",
+			},
+			[]string{"base"},
+		),
+	}
+
+	errs := wrappers.Errs{}
+	errs.Add(
+		registerer.Register(m.numProcessing),
+		registerer.Register(m.numCalls),
+		registerer.Register(m.totalDuration),
+	)
+	return m, errs.Err
+}
+
+func (m *metrics) wrapHandler(chainName string, handler http.Handler) http.Handler {
+	numProcessing := m.numProcessing.WithLabelValues(chainName)
+	numCalls := m.numCalls.WithLabelValues(chainName)
+	totalDuration := m.totalDuration.WithLabelValues(chainName)
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		startTime := time.Now()
+		numProcessing.Inc()
+
+		defer func() {
+			numProcessing.Dec()
+			numCalls.Inc()
+			totalDuration.Add(float64(time.Since(startTime)))
+		}()
+
+		handler.ServeHTTP(w, r)
+	})
+}

avalanchego/api/traced_handler.go

@@ -0,0 +1,47 @@
+// Copyright (C) 2019-2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package api
+
+import (
+	"fmt"
+	"net/http"
+
+	"go.opentelemetry.io/otel/attribute"
+
+	oteltrace "go.opentelemetry.io/otel/trace"
+
+	"github.com/ava-labs/avalanchego/trace"
+)
+
+var _ http.Handler = (*tracedHandler)(nil)
+
+type tracedHandler struct {
+	h            http.Handler
+	serveHTTPTag string
+	tracer       trace.Tracer
+}
+
+func TraceHandler(h http.Handler, name string, tracer trace.Tracer) http.Handler {
+	return &tracedHandler{
+		h:            h,
+		serveHTTPTag: fmt.Sprintf("%s.ServeHTTP", name),
+		tracer:       tracer,
+	}
+}
+
+func (h *tracedHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	ctx, span := h.tracer.Start(ctx, h.serveHTTPTag, oteltrace.WithAttributes(
+		attribute.String("method", r.Method),
+		attribute.String("url", r.URL.Redacted()),
+		attribute.String("proto", r.Proto),
+		attribute.String("host", r.Host),
+		attribute.String("remoteAddr", r.RemoteAddr),
+		attribute.String("requestURI", r.RequestURI),
+	))
+	defer span.End()
+
+	r = r.WithContext(ctx)
+	h.h.ServeHTTP(w, r)
+}

avalanchego/chains/linearizable_vm.go

@@ -0,0 +1,80 @@
+// Copyright (C) 2019-2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package chains
+
+import (
+	"context"
+
+	"github.com/ava-labs/avalanchego/api/metrics"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/snow"
+	"github.com/ava-labs/avalanchego/snow/engine/avalanche/vertex"
+	"github.com/ava-labs/avalanchego/snow/engine/common"
+	"github.com/ava-labs/avalanchego/snow/engine/snowman/block"
+
+	dbManager "github.com/ava-labs/avalanchego/database/manager"
+)
+
+var (
+	_ vertex.LinearizableVM = (*initializeOnLinearizeVM)(nil)
+	_ block.ChainVM         = (*linearizeOnInitializeVM)(nil)
+)
+
+// initializeOnLinearizeVM transforms the consensus engine's call to Linearize
+// into a call to Initialize. This enables the proposervm to be initialized by
+// the call to Linearize. This also provides the stopVertexID to the
+// linearizeOnInitializeVM.
+type initializeOnLinearizeVM struct {
+	vertex.DAGVM
+	vmToInitialize common.VM
+	vmToLinearize  *linearizeOnInitializeVM
+
+	registerer   metrics.OptionalGatherer
+	ctx          *snow.Context
+	dbManager    dbManager.Manager
+	genesisBytes []byte
+	upgradeBytes []byte
+	configBytes  []byte
+	toEngine     chan<- common.Message
+	fxs          []*common.Fx
+	appSender    common.AppSender
+}
+
+func (vm *initializeOnLinearizeVM) Linearize(ctx context.Context, stopVertexID ids.ID) error {
+	vm.vmToLinearize.stopVertexID = stopVertexID
+	vm.ctx.Metrics = vm.registerer
+	return vm.vmToInitialize.Initialize(
+		ctx,
+		vm.ctx,
+		vm.dbManager,
+		vm.genesisBytes,
+		vm.upgradeBytes,
+		vm.configBytes,
+		vm.toEngine,
+		vm.fxs,
+		vm.appSender,
+	)
+}
+
+// linearizeOnInitializeVM transforms the proposervm's call to Initialize into a
+// call to Linearize. This enables the proposervm to provide its toEngine
+// channel to the VM that is being linearized.
+type linearizeOnInitializeVM struct {
+	vertex.LinearizableVMWithEngine
+	stopVertexID ids.ID
+}
+
+func (vm *linearizeOnInitializeVM) Initialize(
+	ctx context.Context,
+	_ *snow.Context,
+	_ dbManager.Manager,
+	_ []byte,
+	_ []byte,
+	_ []byte,
+	toEngine chan<- common.Message,
+	_ []*common.Fx,
+	_ common.AppSender,
+) error {
+	return vm.Linearize(ctx, vm.stopVertexID, toEngine)
+}

avalanchego/chains/test_manager.go

@@ -0,0 +1,65 @@
+// Copyright (C) 2019-2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package chains
+
+import (
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/snow/networking/router"
+)
+
+// TestManager implements Manager but does nothing. Always returns nil error.
+// To be used only in tests
+var TestManager Manager = testManager{}
+
+type testManager struct{}
+
+func (testManager) Router() router.Router {
+	return nil
+}
+
+func (testManager) QueueChainCreation(ChainParameters) {}
+
+func (testManager) ForceCreateChain(ChainParameters) {}
+
+func (testManager) AddRegistrant(Registrant) {}
+
+func (testManager) Aliases(ids.ID) ([]string, error) {
+	return nil, nil
+}
+
+func (testManager) PrimaryAlias(ids.ID) (string, error) {
+	return "", nil
+}
+
+func (testManager) PrimaryAliasOrDefault(ids.ID) string {
+	return ""
+}
+
+func (testManager) Alias(ids.ID, string) error {
+	return nil
+}
+
+func (testManager) RemoveAliases(ids.ID) {}
+
+func (testManager) Shutdown() {}
+
+func (testManager) StartChainCreator(ChainParameters) error {
+	return nil
+}
+
+func (testManager) SubnetID(ids.ID) (ids.ID, error) {
+	return ids.ID{}, nil
+}
+
+func (testManager) IsBootstrapped(ids.ID) bool {
+	return false
+}
+
+func (testManager) Lookup(s string) (ids.ID, error) {
+	return ids.FromString(s)
+}
+
+func (testManager) LookupVM(s string) (ids.ID, error) {
+	return ids.FromString(s)
+}