sync

type ChangeProofRequest struct {
	StartingRoot ids.ID `serialize:"true"`
	EndingRoot   ids.ID `serialize:"true"`
	Start        []byte `serialize:"true"`
	End          []byte `serialize:"true"`
	KeyLimit     uint16 `serialize:"true"`
	BytesLimit   uint32 `serialize:"true"`
}

type Client interface {
	// GetRangeProof synchronously sends the given request, returning a parsed StateResponse or error
	// Note: this verifies the response including the range proof.
	GetRangeProof(ctx context.Context, request *syncpb.RangeProofRequest) (*merkledb.RangeProof, error)
	// GetChangeProof synchronously sends the given request, returning a parsed ChangesResponse or error
	// [verificationDB] is the local db that has all key/values in it for the proof's startroot within the proof's key range
	// Note: this verifies the response including the change proof.
	GetChangeProof(ctx context.Context, request *syncpb.ChangeProofRequest, verificationDB *merkledb.Database) (*merkledb.ChangeProof, error)
}

type ClientConfig struct {
	NetworkClient       NetworkClient
	StateSyncNodeIDs    []ids.NodeID
	StateSyncMinVersion *version.Application
	Log                 logging.Logger
	Metrics             SyncMetrics
}

type Handler interface {
	// contains filtered or unexported methods
}

type MockClient struct {
	// contains filtered or unexported fields
}

type MockClientMockRecorder struct {
	// contains filtered or unexported fields
}

type NetworkClient interface {
	// RequestAny synchronously sends request to an arbitrary peer with a
	// node version greater than or equal to minVersion.
	// Returns response bytes, the ID of the chosen peer, and ErrRequestFailed if
	// the request should be retried.
	RequestAny(ctx context.Context, minVersion *version.Application, request []byte) ([]byte, ids.NodeID, error)

	// Request synchronously sends request to the selected nodeID.
	// Returns response bytes, and ErrRequestFailed if the request should be retried.
	Request(ctx context.Context, nodeID ids.NodeID, request []byte) ([]byte, error)

	// TrackBandwidth should be called for each valid response with the bandwidth
	// (length of response divided by request time), and with 0 if the response is invalid.
	TrackBandwidth(nodeID ids.NodeID, bandwidth float64)

	// The following declarations allow this interface to be embedded in the VM
	// to handle incoming responses from peers.
	AppResponse(context.Context, ids.NodeID, uint32, []byte) error
	AppRequestFailed(context.Context, ids.NodeID, uint32) error
	Connected(context.Context, ids.NodeID, *version.Application) error
	Disconnected(context.Context, ids.NodeID) error
}

type NetworkServer struct {
	// contains filtered or unexported fields
}

type RangeProofRequest struct {
	Root       ids.ID `serialize:"true"`
	Start      []byte `serialize:"true"`
	End        []byte `serialize:"true"`
	KeyLimit   uint16 `serialize:"true"`
	BytesLimit uint32 `serialize:"true"`
}

type Request interface {
	fmt.Stringer
	Handle(ctx context.Context, nodeID ids.NodeID, requestID uint32, h Handler) error
}

type ResponseHandler interface {
	// Called when [response] is received.
	OnResponse(response []byte)
	// Called when the request failed or timed out.
	OnFailure()
}

type StateSyncConfig struct {
	SyncDB                *merkledb.Database
	Client                Client
	SimultaneousWorkLimit int
	Log                   logging.Logger
	TargetRoot            ids.ID
}

type StateSyncManager struct {
	// contains filtered or unexported fields
}

type SyncMetrics interface {
	RequestFailed()
	RequestMade()
	RequestSucceeded()
}