mock

type BlockWithConsenters struct {
	Block             *common.Block
	ConsenterMetadata []byte
	ConsenterSigners  []msp.SigningIdentity
}

type Coordinator struct {
	servicepb.CoordinatorServer
	// contains filtered or unexported fields
}

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

type OrdererConfig struct {
	// Server and ServerConfigs sets the used serving endpoints.
	// We support both for compatibility with other services.
	Server           *connection.ServerConfig   `mapstructure:"server"`
	ServerConfigs    []*connection.ServerConfig `mapstructure:"servers"`
	BlockSize        int                        `mapstructure:"block-size"`
	BlockTimeout     time.Duration              `mapstructure:"block-timeout"`
	OutBlockCapacity int                        `mapstructure:"out-block-capacity"`
	PayloadCacheSize int                        `mapstructure:"payload-cache-size"`
	ArtifactsPath    string                     `mapstructure:"artifacts-path"`
	SendGenesisBlock bool                       `mapstructure:"send-genesis-block"`

	// TestServerParameters is only used for internal testing.
	TestServerParameters test.StartServerParameters
}

type OrdererStreamState struct {
	StreamInfo
	*PartyState
	DataBlockStream bool
}

type OrdererTestEnv struct {
	OrdererTestParameters
	OrdererConnConfig ordererdial.Config
	Orderer           *Orderer
	PrevBlock         *common.Block
	PartyStates       map[uint32]*PartyState
	AllServerConfig   []*connection.ServerConfig
	AllServers        []*grpc.Server
	AllEndpoints      []*commontypes.OrdererEndpoint
}

type OrdererTestParameters struct {
	ArtifactsPath         string
	ChanID                string
	NumIDs                uint32
	ServerPerID           int
	PeerOrganizationCount uint32
	OrdererConfig         *OrdererConfig
	ServerTLSConfig       connection.TLSConfig
	ClientTLSConfig       connection.TLSConfig

	// NewOrdererTestEnv prepares the environment for the entire test.
	// However, the test might choose to start with a subset of the IDs, then
	// add the others as the test progresses.
	// We want to allow this without having to create servers in flight.
	// InitialNumIDs determines the initial number of IDs, to choose for the genesis block.
	// If not initialized, the default is all the IDs.
	InitialNumIDs uint32
}

type PartyState struct {
	PartyID       uint32
	HoldFromBlock atomic.Uint64
	ReplaceBlock  utils.SyncMap[uint64, *common.Block]
}

type StreamFetcher[T any] interface {
	StreamsStates() []*T
	StreamsStatesByServerEndpoints(endpoint ...string) []*T
}

type StreamInfo struct {
	Index          uint64
	ServerEndpoint string
	ClientEndpoint string
}

type VCStreamState struct {
	StreamInfo
	// contains filtered or unexported fields
}

type VcService struct {
	servicepb.ValidationAndCommitServiceServer

	// NumBatchesReceived is the number of batches received by VcService.
	NumBatchesReceived atomic.Uint32
	// MockFaultyNodeDropSize allows mocking a faulty node by dropping some TXs.
	MockFaultyNodeDropSize int
	// contains filtered or unexported fields
}

type Verifier struct {
	servicepb.UnimplementedVerifierServer
	// contains filtered or unexported fields
}

type VerifierStreamState struct {
	StreamInfo

	// Updates contains all the updates received.
	Updates atomic.Pointer[[]*servicepb.VerifierUpdates]
	// NumBlocksReceived is the number of blocks received by the mock verifier.
	NumBlocksReceived atomic.Uint64
	// PolicyUpdateCounter is the number of policy updates, used to check progress.
	PolicyUpdateCounter atomic.Uint64
	// ReturnErrForUpdatePolicies configures the Verifier to return an error during policy updates.
	// When true, the verifier will signal an error during the update policies process.
	// It is a one time event, after which the flag will return to false.
	ReturnErrForUpdatePolicies atomic.Bool
	// MockFaultyNodeDropSize allows mocking a faulty node by dropping some TXs.
	MockFaultyNodeDropSize atomic.Uint64
	// contains filtered or unexported fields
}