api

type BlockSubscription interface {
	Blocks() <-chan *common.Block
	// DEPRECATED: will migrate to just once Err() <- chan error
	Errors() chan error
	Close() error
}

type BlocksDeliverer interface {
	// Blocks - shortcut for core.PeerPool().DeliverClient(mspIdentity).SubscribeBlock(chanName,seekRange).Blocks()
	// subscribe to new blocks on specified channel
	// if provided 'identity' is 'nil' default one will be set
	Blocks(
		ctx context.Context,
		channelName string,
		identity msp.SigningIdentity,
		blockRange ...int64,
	) (blockChan <-chan *common.Block, closer func() error, err error)
}

type CCFetcher interface {
	Fetch(ctx context.Context, id *peer.ChaincodeID) (*peer.ChaincodeDeploymentSpec, error)
}

type CSCC interface {
	// JoinChain allows to join channel using presented genesis block
	JoinChain(ctx context.Context, channelName string, genesisBlock *common.Block) error
	// GetConfigBlock returns genesis block of channel
	GetConfigBlock(ctx context.Context, channelName string) (*common.Block, error)
	// GetChannelConfig returns channel configuration
	GetChannelConfig(ctx context.Context, channelName string) (*common.Config, error)
	ChannelsFetcher
}

type Chaincode interface {
	// Invoke returns invoke builder for presented chaincode function
	Invoke(fn string) ChaincodeInvokeBuilder
	// Query returns query builder for presented function and arguments
	Query(fn string, args ...string) ChaincodeQueryBuilder
	// Deprecated: Install fetches chaincode from repository and installs it on local peer
	Install(version string)
	// Subscribe returns subscription on chaincode events
	Subscribe(ctx context.Context) (EventCCSubscription, error)
}

type ChaincodeDiscoverer interface {
	Endorsers() []*HostEndpoint
	ChaincodeName() string
	ChaincodeVersion() string

	ChannelDiscoverer
}

type ChaincodeInvokeBuilder interface {
	// WithIdentity allows to invoke chaincode from custom identity
	WithIdentity(identity msp.SigningIdentity) ChaincodeInvokeBuilder
	// Transient allows to pass arguments to transient map
	Transient(args TransArgs) ChaincodeInvokeBuilder
	// ArgBytes set slice of bytes as argument
	ArgBytes([][]byte) ChaincodeInvokeBuilder
	// ArgJSON set slice of JSON-marshalled data
	ArgJSON(in ...interface{}) ChaincodeInvokeBuilder
	// ArgString set slice of strings as arguments
	ArgString(args ...string) ChaincodeInvokeBuilder
	// Do makes invoke with built arguments
	Do(ctx context.Context, opts ...DoOption) (*peer.Response, ChaincodeTx, error)
}

type ChaincodeInvokeResponse struct {
	TxID    ChaincodeTx
	Payload []byte
	Err     error
}

type ChaincodePackage interface {
	// Latest allows to get latest version of chaincode
	Latest(ctx context.Context) (*peer.ChaincodeDeploymentSpec, error)
	// Install chaincode using defined chaincode fetcher
	Install(ctx context.Context, path, version string) error
	// Instantiate chaincode on channel with presented params
	Instantiate(ctx context.Context, channelName, path, version, policy string, args [][]byte, transArgs TransArgs) error
}

type ChaincodeQueryBuilder interface {
	// WithIdentity allows to invoke chaincode from custom identity
	WithIdentity(identity msp.SigningIdentity) ChaincodeQueryBuilder
	// WithArguments allows to query chaincode with arguments
	WithArguments(argBytes [][]byte) ChaincodeQueryBuilder
	// Transient allows to pass arguments to transient map
	Transient(args TransArgs) ChaincodeQueryBuilder
	// AsBytes allows to get result of querying chaincode as byte slice
	AsBytes(ctx context.Context) ([]byte, error)
	// AsJSON allows to get result of querying chaincode to presented structures using JSON-unmarshalling
	AsJSON(ctx context.Context, out interface{}) error
	// AsProposalResponse allows to get raw peer response
	AsProposalResponse(ctx context.Context) (*peer.ProposalResponse, error)
	// Do makes query with built arguments
	Do(ctx context.Context) (*peer.Response, error)
}

type ChaincodeTx string

type Channel interface {
	// Chaincode returns chaincode instance by chaincode name
	Chaincode(ctx context.Context, name string) (Chaincode, error)
	// Join channel
	Join(ctx context.Context) error
}

type ChannelDiscoverer interface {
	Orderers() []*HostEndpoint
	ChannelName() string
}

type ChannelsFetcher interface {
	// GetChannels returns list of joined channels
	GetChannels(ctx context.Context) (*peer.ChannelQueryResponse, error)
}

type Core interface {
	// Channel returns channel instance by channel name
	Channel(name string) Channel
	// CurrentIdentity identity returns current signing identity used by core
	CurrentIdentity() msp.SigningIdentity
	// CryptoSuite returns current crypto suite implementation
	CryptoSuite() CryptoSuite
	// System allows access to system chaincodes
	System() SystemCC
	// Current peer pool
	PeerPool() PeerPool
	// Chaincode installation
	Chaincode(name string) ChaincodePackage
	// FabricV2 returns if core works in fabric v2 mode
	FabricV2() bool

	Public
}

type CryptoSuite interface {
	// Sign is used for signing message by presented private key
	Sign(msg []byte, key interface{}) ([]byte, error)
	// Verify is used for verifying signature for presented message and public key
	Verify(publicKey interface{}, msg, sig []byte) error
	// Hash is used for hashing presented data
	Hash(data []byte) []byte
	// NewPrivateKey generates new private key
	NewPrivateKey() (interface{}, error)
	// GetSignatureAlgorithm
	GetSignatureAlgorithm() x509.SignatureAlgorithm
	// Initialize is used for suite instantiation using presented options
	Initialize(opts config.CryptoSuiteOpts) (CryptoSuite, error)
}

type DeliverClient interface {
	// SubscribeCC allows to subscribe on chaincode events using name of channel, chaincode and block offset
	SubscribeCC(ctx context.Context, channelName string, ccName string, seekOpt ...EventCCSeekOption) (EventCCSubscription, error)
	// SubscribeTx allows to subscribe on transaction events by id
	SubscribeTx(ctx context.Context, channelName string, tx ChaincodeTx, seekOpt ...EventCCSeekOption) (TxSubscription, error)
	// SubscribeBlock allows to subscribe on block events. Always returns new instance of block subscription
	SubscribeBlock(ctx context.Context, channelName string, seekOpt ...EventCCSeekOption) (BlockSubscription, error)
}

type DiscoveryProvider interface {
	Chaincode(ctx context.Context, channelName string, ccName string) (ChaincodeDiscoverer, error)
	Channel(ctx context.Context, channelName string) (ChannelDiscoverer, error)
	LocalPeers(ctx context.Context) (LocalPeersDiscoverer, error)
}

type DoOption func(opt *DoOptions) error

type DoOptions struct {
	Identity msp.SigningIdentity
	Pool     PeerPool

	TxWaiter TxWaiter
	// necessary only for 'tx waiter all'
	EndorsingMspIDs []string
}

type EnvelopeParsingError struct {
	Err error
}

type ErrNoReadyPeers struct {
	MspId string
}

type ErrUnexpectedHTTPStatus struct {
	Status int
	Body   []byte
}

type Error string

type EventCCSeekOption func() (*orderer.SeekPosition, *orderer.SeekPosition)

type EventCCSubscription interface {
	// Events initiates internal GRPC stream and returns channel on chaincode events
	Events() chan *peer.ChaincodeEvent

	EventsExtended() chan interface {
		Event() *peer.ChaincodeEvent
		Block() uint64
		TxTimestamp() *timestamp.Timestamp
	}
	// Errors returns errors associated with this subscription
	Errors() chan error
	// Close cancels current subscription
	Close() error
}

type EventsDeliverer interface {
	// Events - shortcut for PeerPool().DeliverClient(...).SubscribeCC(...).Events()
	// subscribe on chaincode events using name of channel, chaincode and block offset
	// if provided 'identity' is 'nil' default one will be set
	Events(
		ctx context.Context,
		channelName string,
		ccName string,
		identity msp.SigningIdentity,
		blockRange ...int64,
	) (events chan interface {
		Event() *peer.ChaincodeEvent
		Block() uint64
		TxTimestamp() *timestamp.Timestamp
	}, closer func() error, err error)
}

type GRPCStreamError struct {
	Code codes.Code
	Err  error
}

type HostAddress struct {
	Address     string
	TLSSettings config.TlsConfig
}

type HostEndpoint struct {
	MspID string
	// each host could have own tls settings
	HostAddresses []*HostAddress
}

type Identity interface {
	// GetSigningIdentity returns signing identity which will use presented crypto suite
	GetSigningIdentity(cs CryptoSuite) msp.SigningIdentity
}

type InvalidTxError struct {
	TxId ChaincodeTx
	Code peer.TxValidationCode
}

type Invoker interface {
	// Invoke method allows to invoke chaincode
	Invoke(ctx context.Context, from msp.SigningIdentity, channel string, chaincode string, fn string, args [][]byte, transArgs TransArgs, doOpts ...DoOption) (*peer.Response, ChaincodeTx, error)
	// Query method allows to query chaincode without sending response to orderer
	Query(ctx context.Context, from msp.SigningIdentity, channel string, chaincode string, fn string, args [][]byte, transArgs TransArgs) (*peer.Response, error)
	// Subscribe allows to subscribe on chaincode events
	Subscribe(ctx context.Context, from msp.SigningIdentity, channel, chaincode string) (EventCCSubscription, error)
}

type LSCC interface {
	// GetChaincodeData returns information about instantiated chaincode on target channel
	GetChaincodeData(ctx context.Context, channelName string, ccName string) (*ccprovider.ChaincodeData, error)
	// GetInstalledChaincodes returns list of installed chaincodes on peer
	GetInstalledChaincodes(ctx context.Context) (*peer.ChaincodeQueryResponse, error)
	// GetChaincodes returns list of instantiated chaincodes on channel
	GetChaincodes(ctx context.Context, channelName string) (*peer.ChaincodeQueryResponse, error)
	// GetDeploymentSpec returns spec for installed chaincode
	GetDeploymentSpec(ctx context.Context, channelName string, ccName string) (*peer.ChaincodeDeploymentSpec, error)
	// Install allows to install chaincode using deployment specification
	Install(ctx context.Context, spec *peer.ChaincodeDeploymentSpec) error
	// Deploys allows to instantiate or upgrade chaincode if instantiated
	// Currently, deploy method is not canonical as lscc implementation, but currently we need to get full proposal and it's response to broadcast to orderer
	Deploy(ctx context.Context, channelName string, spec *peer.ChaincodeDeploymentSpec, policy *common.SignaturePolicyEnvelope, opts ...LSCCDeployOption) (*peer.SignedProposal, *peer.ProposalResponse, error)
}

type LSCCDeployOption func(opts *LSCCDeployOptions) error

type LSCCDeployOptions struct {
	Escc             string
	Vscc             string
	CollectionConfig *common.CollectionConfigPackage
	TransArgs        TransArgs
}

type Lifecycle interface {
	// QueryInstalledChaincode returns chaincode package installed on peer
	QueryInstalledChaincode(ctx context.Context, args *lb.QueryInstalledChaincodeArgs) (
		*lb.QueryInstalledChaincodeResult, error)

	// QueryInstalledChaincodes returns chaincode packages list installed on peer
	QueryInstalledChaincodes(ctx context.Context) (*lb.QueryInstalledChaincodesResult, error)

	// InstallChaincode sets up chaincode package on peer
	InstallChaincode(ctx context.Context, args *lb.InstallChaincodeArgs) (*lb.InstallChaincodeResult, error)

	// ApproveChaincodeDefinitionForMyOrg marks chaincode definition on a channel
	ApproveChaincodeDefinitionForMyOrg(ctx context.Context, channel string, args *lb.ApproveChaincodeDefinitionForMyOrgArgs) error

	// QueryApprovedChaincodeDefinition returns approved chaincode definition
	QueryApprovedChaincodeDefinition(ctx context.Context, channel string, args *lb.QueryApprovedChaincodeDefinitionArgs) (
		*lb.QueryApprovedChaincodeDefinitionResult, error)

	// CheckCommitReadiness returns commitments statuses of participants on chaincode definition
	CheckCommitReadiness(ctx context.Context, channel string, args *lb.CheckCommitReadinessArgs) (
		*lb.CheckCommitReadinessResult, error)

	// CommitChaincodeDefinition the chaincode definition on the channel
	CommitChaincodeDefinition(ctx context.Context, channel string, args *lb.CommitChaincodeDefinitionArgs) (
		*lb.CommitChaincodeDefinitionResult, error)

	// QueryChaincodeDefinition returns chaincode definition committed on the channel
	QueryChaincodeDefinition(ctx context.Context, channel string, args *lb.QueryChaincodeDefinitionArgs) (
		*lb.QueryChaincodeDefinitionResult, error)

	// QueryChaincodeDefinitions returns chaincode definitions committed on the channel
	QueryChaincodeDefinitions(ctx context.Context, channel string, args *lb.QueryChaincodeDefinitionsArgs) (
		*lb.QueryChaincodeDefinitionsResult, error)
}

type LocalPeersDiscoverer interface {
	Peers() []*HostEndpoint
}

type MultiError struct {
	Errors []error
}

type Orderer interface {
	// Broadcast sends envelope to orderer and returns it's result
	Broadcast(ctx context.Context, envelope *common.Envelope) (*orderer.BroadcastResponse, error)
	// Deliver fetches block from orderer by envelope
	Deliver(ctx context.Context, envelope *common.Envelope) (*common.Block, error)
}

type Peer interface {
	// Endorse sends proposal to endorsing peer and returns it's result
	Endorse(ctx context.Context, proposal *peer.SignedProposal, opts ...PeerEndorseOpt) (*peer.ProposalResponse, error)
	// Deliver
	DeliverClient(identity msp.SigningIdentity) (DeliverClient, error)
	// Uri returns url used for grpc connection
	Uri() string
	// Conn returns instance of grpc connection
	Conn() *grpc.ClientConn
	// Close terminates peer connection
	Close() error
}

type PeerEndorseError struct {
	Status  int32
	Message string
}

type PeerEndorseOpt func(opts *PeerEndorseOpts) error

type PeerEndorseOpts struct {
	Context context.Context
}

type PeerPool interface {
	Add(mspId string, peer Peer, strategy PeerPoolCheckStrategy) error
	Process(ctx context.Context, mspId string, proposal *peer.SignedProposal) (*peer.ProposalResponse, error)
	DeliverClient(mspId string, identity msp.SigningIdentity) (DeliverClient, error)
	Close() error
}

type PeerPoolCheckStrategy func(ctx context.Context, peer Peer, alive chan bool)

type PeerProcessor interface {
	// CreateProposal creates signed proposal for presented cc, function and args using signing identity
	CreateProposal(chaincodeName string, identity msp.SigningIdentity, fn string, args [][]byte, transArgs TransArgs) (*peer.SignedProposal, ChaincodeTx, error)
	// Send sends signed proposal to endorsing peers and collects their responses
	Send(ctx context.Context, proposal *peer.SignedProposal, endorsingMspIDs []string, pool PeerPool) ([]*peer.ProposalResponse, error)
}

type Public interface {
	EventsDeliverer
	BlocksDeliverer

	// Invoke - shortcut for invoking chanincodes
	// if provided 'identity' is 'nil' default one will be set
	// txWaiterType - param which identify transaction waiting policy.
	// available: 'self'(wait for one peer of endorser org), 'all'(wait for each organizations from endorsement policy)
	// default is 'self'(even if you pass empty string)
	Invoke(
		ctx context.Context,
		chanName string,
		ccName string,
		args [][]byte,
		identity msp.SigningIdentity,
		transient map[string][]byte,
		txWaiterType string,
	) (res *peer.Response, chaincodeTx string, err error)

	// Query - shortcut for querying chanincodes
	// if provided 'identity' is 'nil' default one will be set
	Query(
		ctx context.Context,
		chanName string,
		ccName string,
		args [][]byte,
		identity msp.SigningIdentity,
		transient map[string][]byte,
	) (*peer.Response, error)
}

type QSCC interface {
	// GetChainInfo allows to get common info about channel blockchain
	GetChainInfo(ctx context.Context, channelName string) (*common.BlockchainInfo, error)
	// GetBlockByNumber allows to get block by number
	GetBlockByNumber(ctx context.Context, channelName string, blockNumber int64) (*common.Block, error)
	// GetBlockByHash allows to get block by hash
	GetBlockByHash(ctx context.Context, channelName string, blockHash []byte) (*common.Block, error)
	// GetTransactionByID allows to get transaction by id
	GetTransactionByID(ctx context.Context, channelName string, tx ChaincodeTx) (*peer.ProcessedTransaction, error)
	// GetBlockByTxID allows to get block by transaction
	GetBlockByTxID(ctx context.Context, channelName string, tx ChaincodeTx) (*common.Block, error)
}

type SystemCC interface {
	CSCC() CSCC
	QSCC() QSCC
	LSCC() LSCC
	Lifecycle() Lifecycle
}

type TransArgs map[string][]byte

type TxEvent struct {
	TxId    ChaincodeTx
	Success bool
	Error   error
}

type TxSubscription interface {
	// returns result of current tx: success flag, original peer validation code and error if occurred
	Result() (peer.TxValidationCode, error)
	Close() error
}

type TxWaiter interface {
	Wait(ctx context.Context, channel string, txid ChaincodeTx) error
}

type UnknownEventTypeError struct {
	Type string
}