-
Notifications
You must be signed in to change notification settings - Fork 100
/
contract.go
128 lines (110 loc) · 6.03 KB
/
contract.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
// Copyright the Hyperledger Fabric contributors. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package contractapi
import "github.com/hyperledger/fabric-contract-api-go/metadata"
// IgnoreContractInterface extends ContractInterface and provides additional functionality
// that can be used to mark which functions should not be accessible by invoking/querying
// chaincode
type IgnoreContractInterface interface {
// GetIgnoredFunctions returns a list of function names for functions that should not
// be included in the produced metadata or accessible by invoking/querying the chaincode.
// Note these functions are still callable by the code just not directly by outside users.
// Those that match functions in the ChaincodeInterface are ignored by default and do not
// need to be included
GetIgnoredFunctions() []string
}
// EvaluationContractInterface extends ContractInterface and provides additional functionality
// that can be used to improve metadata
type EvaluationContractInterface interface {
// GetEvaluateTransactions returns a list of function names that should be tagged in the
// metadata as "evaluate" to indicate to a user of the chaincode that they should query
// rather than invoke these functions
GetEvaluateTransactions() []string
}
// ContractInterface defines functions a valid contract should have. Contracts to
// be used in chaincode must implement this interface.
type ContractInterface interface {
// GetInfo returns the information stored for the contract. This information will be
// used to build up the metadata. If version is left blank in this info then "latest"
// will be used in the metadata. If title is blank then the contract's GetName will be
// used, if that is blank then the contract struct name
GetInfo() metadata.InfoMetadata
// GetUnknownTransaction returns the unknown function to be used for a contract.
// When the contract is used in creating a new chaincode this function is called
// and the unknown transaction returned is stored. The unknown function is then
// called in cases where an unknown function name is passed for a call to the
// contract via Init/Invoke of the chaincode. If nil is returned the
// chaincode uses its default handling for unknown function names
GetUnknownTransaction() interface{}
// GetBeforeTransaction returns the before function to be used for a contract.
// When the contract is used in creating a new chaincode this function is called
// and the before transaction returned is stored. The before function is then
// called before the named function on each Init/Invoke of that contract via the
// chaincode. When called the before function is passed no extra args, only the
// the transaction context (if specified to take it). If nil is returned
// then no before function is called on Init/Invoke.
GetBeforeTransaction() interface{}
// GetAfterTransaction returns the after function to be used for a contract.
// When the contract is used in creating a new chaincode this function is called
// and the after transaction returned is stored. The after function is then
// called after the named function on each Init/Invoke of that contract via the
// chaincode. When called the after function is passed the returned value of the
// named function and the transaction context (if the function takes the transaction
// context). If nil is returned then no after function is called on Init/
// Invoke.
GetAfterTransaction() interface{}
// GetName returns the name of the contract. When the contract is used
// in creating a new chaincode this function is called and the name returned
// is then used to identify the contract within the chaincode on Init/Invoke calls.
// This function can return a blank string but this is undefined behaviour.
GetName() string
// GetTransactionContextHandler returns the SettableTransactionContextInterface that is
// used by the functions of the contract. When the contract is used in creating
// a new chaincode this function is called and the transaction context returned
// is stored. When the chaincode is called via Init/Invoke a transaction context
// of the stored type is created and sent as a parameter to the named contract
// function (and before/after and unknown functions) if the function requires the
// context in its list of parameters. If functions taking the transaction context
// take an interface as the context, the transaction context returned by this function
// must meet that interface
GetTransactionContextHandler() SettableTransactionContextInterface
}
// Contract defines functions for setting and getting before, after and unknown transactions
// and name. Can be embedded in structs to quickly ensure their definition meets the
// ContractInterface.
type Contract struct {
Name string
Info metadata.InfoMetadata
UnknownTransaction interface{}
BeforeTransaction interface{}
AfterTransaction interface{}
TransactionContextHandler SettableTransactionContextInterface
}
// GetInfo returns the info about the contract for use in metadata
func (c *Contract) GetInfo() metadata.InfoMetadata {
return c.Info
}
// GetUnknownTransaction returns the current set unknownTransaction, may be nil
func (c *Contract) GetUnknownTransaction() interface{} {
return c.UnknownTransaction
}
// GetBeforeTransaction returns the current set beforeTransaction, may be nil
func (c *Contract) GetBeforeTransaction() interface{} {
return c.BeforeTransaction
}
// GetAfterTransaction returns the current set afterTransaction, may be nil
func (c *Contract) GetAfterTransaction() interface{} {
return c.AfterTransaction
}
// GetName returns the name of the contract
func (c *Contract) GetName() string {
return c.Name
}
// GetTransactionContextHandler returns the current transaction context set for
// the contract. If none has been set then TransactionContext will be returned
func (c *Contract) GetTransactionContextHandler() SettableTransactionContextInterface {
if c.TransactionContextHandler == nil {
return new(TransactionContext)
}
return c.TransactionContextHandler
}