fabricclient

type Chain ¶

type Chain interface {
	GetName() string
	Initialize(data []byte) error
	IsSecurityEnabled() bool
	GetTCertBatchSize() int
	SetTCertBatchSize(batchSize int)
	AddPeer(peer Peer) error
	RemovePeer(peer Peer)
	GetPeers() []Peer
	GetAnchorPeers() []OrgAnchorPeer
	SetPrimaryPeer(peer Peer) error
	GetPrimaryPeer() Peer
	AddOrderer(orderer Orderer) error
	RemoveOrderer(orderer Orderer)
	GetOrderers() []Orderer
	SetMSPManager(mspManager msp.MSPManager)
	GetMSPManager() msp.MSPManager
	GetGenesisBlock(request *GenesisBlockRequest) (*common.Block, error)
	JoinChannel(request *JoinChannelRequest) ([]*TransactionProposalResponse, error)
	UpdateChain() bool
	IsReadonly() bool
	QueryInfo() (*common.BlockchainInfo, error)
	QueryBlock(blockNumber int) (*common.Block, error)
	QueryBlockByHash(blockHash []byte) (*common.Block, error)
	QueryTransaction(transactionID string) (*pb.ProcessedTransaction, error)
	QueryInstantiatedChaincodes() (*pb.ChaincodeQueryResponse, error)
	QueryByChaincode(chaincodeName string, args []string, targets []Peer) ([][]byte, error)
	CreateTransactionProposal(chaincodeName string, chainID string, args []string, sign bool, transientData map[string][]byte) (*TransactionProposal, error)
	SendTransactionProposal(proposal *TransactionProposal, retry int, targets []Peer) ([]*TransactionProposalResponse, error)
	CreateTransaction(resps []*TransactionProposalResponse) (*Transaction, error)
	SendTransaction(tx *Transaction) ([]*TransactionResponse, error)
	SendInstantiateProposal(chaincodeName string, chainID string, args []string, chaincodePath string, chaincodeVersion string, targets []Peer) ([]*TransactionProposalResponse, string, error)
	GetOrganizationUnits() ([]string, error)
	QueryExtensionInterface() ChainExtension
	LoadConfigUpdateEnvelope(data []byte) error
}

Chain ... *

• Chain representing a chain with which the client SDK interacts. *
• The “Chain” object captures settings for a channel, which is created by
• the orderers to isolate transactions delivery to peers participating on channel.
• A chain must be initialized after it has been configured with the list of peers
• and orderers. The initialization sends a get configuration block request to the
• primary orderer to retrieve the configuration settings for this channel.

func NewChain(name string, client Client) (Chain, error)

type ChainExtension ¶

type ChainExtension interface {
	GetClientContext() Client

	SignPayload(payload []byte) (*SignedEnvelope, error)
	BroadcastEnvelope(envelope *SignedEnvelope) ([]*TransactionResponse, error)

	// TODO: This should go somewhere else - see TransactionProposal.GetBytes(). - deprecated
	GetProposalBytes(tp *TransactionProposal) ([]byte, error)
}

The ChainExtension interface allows extensions of the SDK to add functionality to Chain overloads.

type Client ¶

type Client interface {
	NewChain(name string) (Chain, error)
	GetChain(name string) Chain
	ExtractChannelConfig(configEnvelope []byte) ([]byte, error)
	SignChannelConfig(config []byte) (*common.ConfigSignature, error)
	CreateChannel(request *CreateChannelRequest) error
	QueryChainInfo(name string, peers []Peer) (Chain, error)
	SetStateStore(stateStore kvs.KeyValueStore)
	GetStateStore() kvs.KeyValueStore
	SetCryptoSuite(cryptoSuite bccsp.BCCSP)
	GetCryptoSuite() bccsp.BCCSP
	SaveUserToStateStore(user User, skipPersistence bool) error
	LoadUserFromStateStore(name string) (User, error)
	InstallChaincode(chaincodeName string, chaincodePath string, chaincodeVersion string, chaincodePackage []byte, targets []Peer) ([]*TransactionProposalResponse, string, error)
	QueryChannels(peer Peer) (*pb.ChannelQueryResponse, error)
	QueryInstalledChaincodes(peer Peer) (*pb.ChaincodeQueryResponse, error)
	GetIdentity() ([]byte, error)
	GetUserContext() User
	SetUserContext(user User)
}

Client ...

• Main interaction handler with end user. A client instance provides a handler to interact
• with a network of peers, orderers and optionally member services. An application using the
• SDK may need to interact with multiple networks, each through a separate instance of the Client. *
• Each client when initially created should be initialized with configuration data from the
• consensus service, which includes a list of trusted roots, orderer certificates and IP addresses,
• and a list of peer certificates and IP addresses that it can access. This must be done out of band
• as part of bootstrapping the application environment. It is also the responsibility of the application
• to maintain the configuration of a client as the SDK does not persist this object. *
• Each Client instance can maintain several {@link Chain} instances representing channels and the associated
• private ledgers. * *

func NewClient() Client

type CreateChannelRequest ¶

type CreateChannelRequest struct {
	// required - The name of the new channel
	Name string
	// required - The Orderer to send the update request
	Orderer Orderer
	// optional - the envelope object containing all
	// required settings and signatures to initialize this channel.
	// This envelope would have been created by the command
	// line tool "configtx"
	Envelope []byte
	// optional - ConfigUpdate object built by the
	// buildChannelConfig() method of this package
	Config []byte
	// optional - the list of collected signatures
	// required by the channel create policy when using the `config` parameter.
	// see signChannelConfig() method of this package
	Signatures []*common.ConfigSignature
	// optional - transaction ID
	// required when using the `config` parameter
	TxID string
	// optional - nonce
	// required when using the `config` parameter
	Nonce []byte
}

CreateChannelRequest requests channel creation on the network

type GenesisBlockRequest ¶

type GenesisBlockRequest struct {
	TxID  string
	Nonce []byte
}

GenesisBlockRequest ...

type JoinChannelRequest ¶

type JoinChannelRequest struct {
	Targets      []Peer
	GenesisBlock *common.Block
	TxID         string
	Nonce        []byte
}

JoinChannelRequest allows a set of peers to transact on a channel on the network

type MockBroadcastServer ¶

type MockBroadcastServer struct {
	DeliverError                 error
	BroadcastInternalServerError bool
}

MockBroadcastServer mock broadcast server

func (m *MockBroadcastServer) Broadcast(server po.AtomicBroadcast_BroadcastServer) error

func (m *MockBroadcastServer) Deliver(server po.AtomicBroadcast_DeliverServer) error

type MockConfigBlockBuilder ¶

type MockConfigBlockBuilder struct {
	MockConfigGroupBuilder
	Index           uint64
	LastConfigIndex uint64
}

MockConfigBlockBuilder is used to build a mock Chain configuration block

func (b *MockConfigBlockBuilder) Build() *common.Block

type MockConfigGroupBuilder ¶

type MockConfigGroupBuilder struct {
	Version        uint64
	ModPolicy      string
	OrdererAddress string
	MSPNames       []string
	RootCA         string
}

MockConfigGroupBuilder is used to build a mock ConfigGroup

type MockConfigUpdateEnvelopeBuilder ¶

type MockConfigUpdateEnvelopeBuilder struct {
	MockConfigGroupBuilder
	ChannelID string
}

MockConfigUpdateEnvelopeBuilder builds a mock ConfigUpdateEnvelope

func (b *MockConfigUpdateEnvelopeBuilder) Build() *common.Envelope

func (b *MockConfigUpdateEnvelopeBuilder) BuildBytes() []byte

type MockCryptoSuite ¶

type MockCryptoSuite struct {
}

MockCryptoSuite implementation

func (m *MockCryptoSuite) Decrypt(k bccsp.Key, ciphertext []byte,
	opts bccsp.DecrypterOpts) (plaintext []byte, err error)

func (m *MockCryptoSuite) Encrypt(k bccsp.Key, plaintext []byte,
	opts bccsp.EncrypterOpts) (ciphertext []byte, err error)

func (m *MockCryptoSuite) GetHash(opts bccsp.HashOpts) (h hash.Hash, err error)

func (m *MockCryptoSuite) GetKey(ski []byte) (k bccsp.Key, err error)

func (m *MockCryptoSuite) Hash(msg []byte, opts bccsp.HashOpts) (hash []byte, err error)

func (m *MockCryptoSuite) KeyDeriv(k bccsp.Key,
	opts bccsp.KeyDerivOpts) (dk bccsp.Key, err error)

func (m *MockCryptoSuite) KeyGen(opts bccsp.KeyGenOpts) (k bccsp.Key, err error)

func (m *MockCryptoSuite) KeyImport(raw interface{},
	opts bccsp.KeyImportOpts) (k bccsp.Key, err error)

func (m *MockCryptoSuite) Sign(k bccsp.Key, digest []byte,
	opts bccsp.SignerOpts) (signature []byte, err error)

func (m *MockCryptoSuite) Verify(k bccsp.Key, signature, digest []byte,
	opts bccsp.SignerOpts) (valid bool, err error)

type MockEndorserServer ¶

type MockEndorserServer struct {
	ProposalError error
	AddkvWrite    bool
}

MockEndorserServer mock endoreser server to process endorsement proposals

func (m *MockEndorserServer) ProcessProposal(context context.Context,
	proposal *pb.SignedProposal) (*pb.ProposalResponse, error)

type MockOrderer ¶

type MockOrderer interface {
	Orderer
	// Enqueues a mock error to be returned to the client calling SendBroadcast
	EnqueueSendBroadcastError(err error)
	// Enqueues a mock value (block or error) for delivery
	EnqueueForSendDeliver(value interface{})
}

MockOrderer is a mock fabricclient.Orderer Nothe that calling broadcast doesn't deliver anythng. This implies that the broadcast side and the deliver side are totally independent from the mocking point of view.

type Orderer ¶

type Orderer interface {
	GetURL() string
	SendBroadcast(envelope *SignedEnvelope) (*common.Status, error)
	SendDeliver(envelope *SignedEnvelope) (chan *common.Block, chan error)
}

Orderer The Orderer class represents a peer in the target blockchain network to which HFC sends a block of transactions of endorsed proposals requiring ordering.

func CreateNewOrdererWithRootCAs(url string, ordererRootCAs [][]byte, serverHostOverride string) (Orderer, error)

func NewMockOrderer(url string, broadcastListener chan *SignedEnvelope) Orderer

func NewOrderer(url string, certificate string, serverHostOverride string) (Orderer, error)

type OrgAnchorPeer ¶

type OrgAnchorPeer struct {
	Org  string
	Host string
	Port int32
}

OrgAnchorPeer contains information about an anchor peer on this chain

type Peer ¶

type Peer interface {
	ConnectEventSource()
	IsEventListened(event string, chain Chain) (bool, error)
	AddListener(eventType string, eventTypeData interface{}, eventCallback interface{}) (string, error)
	RemoveListener(eventListenerRef string) (bool, error)
	GetName() string
	SetName(name string)
	GetRoles() []string
	SetRoles(roles []string)
	GetEnrollmentCertificate() *pem.Block
	SetEnrollmentCertificate(pem *pem.Block)
	GetURL() string
	SendProposal(proposal *TransactionProposal) (*TransactionProposalResponse, error)
}

Peer ... *

• The Peer class represents a peer in the target blockchain network to which
• HFC sends endorsement proposals, transaction ordering or query requests. *
• The Peer class represents the remote Peer node and its network membership materials,
• aka the ECert used to verify signatures. Peer membership represents organizations,
• unlike User membership which represents individuals. *
• When constructed, a Peer instance can be designated as an event source, in which case
• a “eventSourceUrl” attribute should be configured. This allows the SDK to automatically
• attach transaction event listeners to the event stream. *
• It should be noted that Peer event streams function at the Peer level and not at the
• chain and chaincode levels.

func NewPeer(url string, certificate string, serverHostOverride string) (Peer, error)

type SignedEnvelope ¶

type SignedEnvelope struct {
	Payload   []byte
	Signature []byte
}

A SignedEnvelope can can be sent to an orderer for broadcasting

type Transaction ¶

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

The Transaction object created from an endorsed proposal

type TransactionProposal ¶

type TransactionProposal struct {
	TransactionID string

	SignedProposal *pb.SignedProposal
	Proposal       *pb.Proposal
}

The TransactionProposal object to be send to the endorsers

func CreateTransactionProposal(chaincodeName string, chainID string,
	args []string, sign bool, transientData map[string][]byte, clientContext Client) (*TransactionProposal, error)

func (tp *TransactionProposal) GetBytes() ([]byte, error)

type TransactionProposalResponse ¶

type TransactionProposalResponse struct {
	Endorser string
	Err      error
	Status   int32

	Proposal         *TransactionProposal
	ProposalResponse *pb.ProposalResponse
}

TransactionProposalResponse ... *

• The TransactionProposalResponse result object returned from endorsers.

func SendTransactionProposal(proposal *TransactionProposal, retry int, targetPeers []Peer) ([]*TransactionProposalResponse, error)

func (tpr *TransactionProposalResponse) GetPayload() []byte

func (tpr *TransactionProposalResponse) GetResponsePayload() []byte

type TransactionResponse ¶

type TransactionResponse struct {
	Orderer string
	Err     error
}

TransactionResponse ... *

• The TransactionProposalResponse result object returned from orderers.

type User ¶

type User interface {
	GetName() string
	GetRoles() []string
	SetRoles([]string)
	GetEnrollmentCertificate() []byte
	SetEnrollmentCertificate(cert []byte)
	SetPrivateKey(privateKey bccsp.Key)
	GetPrivateKey() bccsp.Key
	GenerateTcerts(count int, attributes []string)
}

User ... *

• The User struct represents users that have been enrolled and represented by
• an enrollment certificate (ECert) and a signing key. The ECert must have
• been signed by one of the CAs the blockchain network has been configured to trust.
• An enrolled user (having a signing key and ECert) can conduct chaincode deployments,
• transactions and queries with the Chain. *
• User ECerts can be obtained from a CA beforehand as part of deploying the application,
• or it can be obtained from the optional Fabric COP service via its enrollment process. *
• Sometimes User identities are confused with Peer identities. User identities represent
• signing capability because it has access to the private key, while Peer identities in
• the context of the application/SDK only has the certificate for verifying signatures.
• An application cannot use the Peer identity to sign things because the application doesn’t
• have access to the Peer identity’s private key. *

func NewUser(name string) User

type UserJSON ¶

type UserJSON struct {
	PrivateKeySKI         []byte
	EnrollmentCertificate []byte
}

UserJSON ...