diff --git a/core/chaincode/lifecycle/mock/chaincode_stub.go b/core/chaincode/lifecycle/mock/chaincode_stub.go
index b1283fa5db9..712b8f05ac1 100644
--- a/core/chaincode/lifecycle/mock/chaincode_stub.go
+++ b/core/chaincode/lifecycle/mock/chaincode_stub.go
@@ -148,6 +148,33 @@ type ChaincodeStub struct {
result1 shim.HistoryQueryIteratorInterface
result2 error
}
+ GetMultiplePrivateDataStub func(string, ...string) ([][]byte, error)
+ getMultiplePrivateDataMutex sync.RWMutex
+ getMultiplePrivateDataArgsForCall []struct {
+ arg1 string
+ arg2 []string
+ }
+ getMultiplePrivateDataReturns struct {
+ result1 [][]byte
+ result2 error
+ }
+ getMultiplePrivateDataReturnsOnCall map[int]struct {
+ result1 [][]byte
+ result2 error
+ }
+ GetMultipleStatesStub func(...string) ([][]byte, error)
+ getMultipleStatesMutex sync.RWMutex
+ getMultipleStatesArgsForCall []struct {
+ arg1 []string
+ }
+ getMultipleStatesReturns struct {
+ result1 [][]byte
+ result2 error
+ }
+ getMultipleStatesReturnsOnCall map[int]struct {
+ result1 [][]byte
+ result2 error
+ }
GetPrivateDataStub func(string, string) ([]byte, error)
getPrivateDataMutex sync.RWMutex
getPrivateDataArgsForCall []struct {
@@ -1213,6 +1240,135 @@ func (fake *ChaincodeStub) GetHistoryForKeyReturnsOnCall(i int, result1 shim.His
}{result1, result2}
}
+func (fake *ChaincodeStub) GetMultiplePrivateData(arg1 string, arg2 ...string) ([][]byte, error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ ret, specificReturn := fake.getMultiplePrivateDataReturnsOnCall[len(fake.getMultiplePrivateDataArgsForCall)]
+ fake.getMultiplePrivateDataArgsForCall = append(fake.getMultiplePrivateDataArgsForCall, struct {
+ arg1 string
+ arg2 []string
+ }{arg1, arg2})
+ stub := fake.GetMultiplePrivateDataStub
+ fakeReturns := fake.getMultiplePrivateDataReturns
+ fake.recordInvocation("GetMultiplePrivateData", []interface{}{arg1, arg2})
+ fake.getMultiplePrivateDataMutex.Unlock()
+ if stub != nil {
+ return stub(arg1, arg2...)
+ }
+ if specificReturn {
+ return ret.result1, ret.result2
+ }
+ return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataCallCount() int {
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ return len(fake.getMultiplePrivateDataArgsForCall)
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataCalls(stub func(string, ...string) ([][]byte, error)) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = stub
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataArgsForCall(i int) (string, []string) {
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ argsForCall := fake.getMultiplePrivateDataArgsForCall[i]
+ return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataReturns(result1 [][]byte, result2 error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = nil
+ fake.getMultiplePrivateDataReturns = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataReturnsOnCall(i int, result1 [][]byte, result2 error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = nil
+ if fake.getMultiplePrivateDataReturnsOnCall == nil {
+ fake.getMultiplePrivateDataReturnsOnCall = make(map[int]struct {
+ result1 [][]byte
+ result2 error
+ })
+ }
+ fake.getMultiplePrivateDataReturnsOnCall[i] = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultipleStates(arg1 ...string) ([][]byte, error) {
+ fake.getMultipleStatesMutex.Lock()
+ ret, specificReturn := fake.getMultipleStatesReturnsOnCall[len(fake.getMultipleStatesArgsForCall)]
+ fake.getMultipleStatesArgsForCall = append(fake.getMultipleStatesArgsForCall, struct {
+ arg1 []string
+ }{arg1})
+ stub := fake.GetMultipleStatesStub
+ fakeReturns := fake.getMultipleStatesReturns
+ fake.recordInvocation("GetMultipleStates", []interface{}{arg1})
+ fake.getMultipleStatesMutex.Unlock()
+ if stub != nil {
+ return stub(arg1...)
+ }
+ if specificReturn {
+ return ret.result1, ret.result2
+ }
+ return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesCallCount() int {
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
+ return len(fake.getMultipleStatesArgsForCall)
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesCalls(stub func(...string) ([][]byte, error)) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = stub
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesArgsForCall(i int) []string {
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
+ argsForCall := fake.getMultipleStatesArgsForCall[i]
+ return argsForCall.arg1
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesReturns(result1 [][]byte, result2 error) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = nil
+ fake.getMultipleStatesReturns = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesReturnsOnCall(i int, result1 [][]byte, result2 error) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = nil
+ if fake.getMultipleStatesReturnsOnCall == nil {
+ fake.getMultipleStatesReturnsOnCall = make(map[int]struct {
+ result1 [][]byte
+ result2 error
+ })
+ }
+ fake.getMultipleStatesReturnsOnCall[i] = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
func (fake *ChaincodeStub) GetPrivateData(arg1 string, arg2 string) ([]byte, error) {
fake.getPrivateDataMutex.Lock()
ret, specificReturn := fake.getPrivateDataReturnsOnCall[len(fake.getPrivateDataArgsForCall)]
@@ -3010,6 +3166,10 @@ func (fake *ChaincodeStub) Invocations() map[string][][]interface{} {
defer fake.getFunctionAndParametersMutex.RUnlock()
fake.getHistoryForKeyMutex.RLock()
defer fake.getHistoryForKeyMutex.RUnlock()
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
fake.getPrivateDataMutex.RLock()
defer fake.getPrivateDataMutex.RUnlock()
fake.getPrivateDataByPartialCompositeKeyMutex.RLock()
diff --git a/core/scc/cscc/mocks/chaincode_stub.go b/core/scc/cscc/mocks/chaincode_stub.go
index 68c1ce1d781..2498bfc29d5 100644
--- a/core/scc/cscc/mocks/chaincode_stub.go
+++ b/core/scc/cscc/mocks/chaincode_stub.go
@@ -148,6 +148,33 @@ type ChaincodeStub struct {
result1 shim.HistoryQueryIteratorInterface
result2 error
}
+ GetMultiplePrivateDataStub func(string, ...string) ([][]byte, error)
+ getMultiplePrivateDataMutex sync.RWMutex
+ getMultiplePrivateDataArgsForCall []struct {
+ arg1 string
+ arg2 []string
+ }
+ getMultiplePrivateDataReturns struct {
+ result1 [][]byte
+ result2 error
+ }
+ getMultiplePrivateDataReturnsOnCall map[int]struct {
+ result1 [][]byte
+ result2 error
+ }
+ GetMultipleStatesStub func(...string) ([][]byte, error)
+ getMultipleStatesMutex sync.RWMutex
+ getMultipleStatesArgsForCall []struct {
+ arg1 []string
+ }
+ getMultipleStatesReturns struct {
+ result1 [][]byte
+ result2 error
+ }
+ getMultipleStatesReturnsOnCall map[int]struct {
+ result1 [][]byte
+ result2 error
+ }
GetPrivateDataStub func(string, string) ([]byte, error)
getPrivateDataMutex sync.RWMutex
getPrivateDataArgsForCall []struct {
@@ -1213,6 +1240,135 @@ func (fake *ChaincodeStub) GetHistoryForKeyReturnsOnCall(i int, result1 shim.His
}{result1, result2}
}
+func (fake *ChaincodeStub) GetMultiplePrivateData(arg1 string, arg2 ...string) ([][]byte, error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ ret, specificReturn := fake.getMultiplePrivateDataReturnsOnCall[len(fake.getMultiplePrivateDataArgsForCall)]
+ fake.getMultiplePrivateDataArgsForCall = append(fake.getMultiplePrivateDataArgsForCall, struct {
+ arg1 string
+ arg2 []string
+ }{arg1, arg2})
+ stub := fake.GetMultiplePrivateDataStub
+ fakeReturns := fake.getMultiplePrivateDataReturns
+ fake.recordInvocation("GetMultiplePrivateData", []interface{}{arg1, arg2})
+ fake.getMultiplePrivateDataMutex.Unlock()
+ if stub != nil {
+ return stub(arg1, arg2...)
+ }
+ if specificReturn {
+ return ret.result1, ret.result2
+ }
+ return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataCallCount() int {
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ return len(fake.getMultiplePrivateDataArgsForCall)
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataCalls(stub func(string, ...string) ([][]byte, error)) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = stub
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataArgsForCall(i int) (string, []string) {
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ argsForCall := fake.getMultiplePrivateDataArgsForCall[i]
+ return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataReturns(result1 [][]byte, result2 error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = nil
+ fake.getMultiplePrivateDataReturns = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataReturnsOnCall(i int, result1 [][]byte, result2 error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = nil
+ if fake.getMultiplePrivateDataReturnsOnCall == nil {
+ fake.getMultiplePrivateDataReturnsOnCall = make(map[int]struct {
+ result1 [][]byte
+ result2 error
+ })
+ }
+ fake.getMultiplePrivateDataReturnsOnCall[i] = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultipleStates(arg1 ...string) ([][]byte, error) {
+ fake.getMultipleStatesMutex.Lock()
+ ret, specificReturn := fake.getMultipleStatesReturnsOnCall[len(fake.getMultipleStatesArgsForCall)]
+ fake.getMultipleStatesArgsForCall = append(fake.getMultipleStatesArgsForCall, struct {
+ arg1 []string
+ }{arg1})
+ stub := fake.GetMultipleStatesStub
+ fakeReturns := fake.getMultipleStatesReturns
+ fake.recordInvocation("GetMultipleStates", []interface{}{arg1})
+ fake.getMultipleStatesMutex.Unlock()
+ if stub != nil {
+ return stub(arg1...)
+ }
+ if specificReturn {
+ return ret.result1, ret.result2
+ }
+ return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesCallCount() int {
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
+ return len(fake.getMultipleStatesArgsForCall)
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesCalls(stub func(...string) ([][]byte, error)) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = stub
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesArgsForCall(i int) []string {
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
+ argsForCall := fake.getMultipleStatesArgsForCall[i]
+ return argsForCall.arg1
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesReturns(result1 [][]byte, result2 error) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = nil
+ fake.getMultipleStatesReturns = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesReturnsOnCall(i int, result1 [][]byte, result2 error) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = nil
+ if fake.getMultipleStatesReturnsOnCall == nil {
+ fake.getMultipleStatesReturnsOnCall = make(map[int]struct {
+ result1 [][]byte
+ result2 error
+ })
+ }
+ fake.getMultipleStatesReturnsOnCall[i] = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
func (fake *ChaincodeStub) GetPrivateData(arg1 string, arg2 string) ([]byte, error) {
fake.getPrivateDataMutex.Lock()
ret, specificReturn := fake.getPrivateDataReturnsOnCall[len(fake.getPrivateDataArgsForCall)]
@@ -3010,6 +3166,10 @@ func (fake *ChaincodeStub) Invocations() map[string][][]interface{} {
defer fake.getFunctionAndParametersMutex.RUnlock()
fake.getHistoryForKeyMutex.RLock()
defer fake.getHistoryForKeyMutex.RUnlock()
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
fake.getPrivateDataMutex.RLock()
defer fake.getPrivateDataMutex.RUnlock()
fake.getPrivateDataByPartialCompositeKeyMutex.RLock()
diff --git a/core/scc/lscc/mock/chaincode_stub.go b/core/scc/lscc/mock/chaincode_stub.go
index b1283fa5db9..712b8f05ac1 100644
--- a/core/scc/lscc/mock/chaincode_stub.go
+++ b/core/scc/lscc/mock/chaincode_stub.go
@@ -148,6 +148,33 @@ type ChaincodeStub struct {
result1 shim.HistoryQueryIteratorInterface
result2 error
}
+ GetMultiplePrivateDataStub func(string, ...string) ([][]byte, error)
+ getMultiplePrivateDataMutex sync.RWMutex
+ getMultiplePrivateDataArgsForCall []struct {
+ arg1 string
+ arg2 []string
+ }
+ getMultiplePrivateDataReturns struct {
+ result1 [][]byte
+ result2 error
+ }
+ getMultiplePrivateDataReturnsOnCall map[int]struct {
+ result1 [][]byte
+ result2 error
+ }
+ GetMultipleStatesStub func(...string) ([][]byte, error)
+ getMultipleStatesMutex sync.RWMutex
+ getMultipleStatesArgsForCall []struct {
+ arg1 []string
+ }
+ getMultipleStatesReturns struct {
+ result1 [][]byte
+ result2 error
+ }
+ getMultipleStatesReturnsOnCall map[int]struct {
+ result1 [][]byte
+ result2 error
+ }
GetPrivateDataStub func(string, string) ([]byte, error)
getPrivateDataMutex sync.RWMutex
getPrivateDataArgsForCall []struct {
@@ -1213,6 +1240,135 @@ func (fake *ChaincodeStub) GetHistoryForKeyReturnsOnCall(i int, result1 shim.His
}{result1, result2}
}
+func (fake *ChaincodeStub) GetMultiplePrivateData(arg1 string, arg2 ...string) ([][]byte, error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ ret, specificReturn := fake.getMultiplePrivateDataReturnsOnCall[len(fake.getMultiplePrivateDataArgsForCall)]
+ fake.getMultiplePrivateDataArgsForCall = append(fake.getMultiplePrivateDataArgsForCall, struct {
+ arg1 string
+ arg2 []string
+ }{arg1, arg2})
+ stub := fake.GetMultiplePrivateDataStub
+ fakeReturns := fake.getMultiplePrivateDataReturns
+ fake.recordInvocation("GetMultiplePrivateData", []interface{}{arg1, arg2})
+ fake.getMultiplePrivateDataMutex.Unlock()
+ if stub != nil {
+ return stub(arg1, arg2...)
+ }
+ if specificReturn {
+ return ret.result1, ret.result2
+ }
+ return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataCallCount() int {
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ return len(fake.getMultiplePrivateDataArgsForCall)
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataCalls(stub func(string, ...string) ([][]byte, error)) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = stub
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataArgsForCall(i int) (string, []string) {
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ argsForCall := fake.getMultiplePrivateDataArgsForCall[i]
+ return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataReturns(result1 [][]byte, result2 error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = nil
+ fake.getMultiplePrivateDataReturns = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataReturnsOnCall(i int, result1 [][]byte, result2 error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = nil
+ if fake.getMultiplePrivateDataReturnsOnCall == nil {
+ fake.getMultiplePrivateDataReturnsOnCall = make(map[int]struct {
+ result1 [][]byte
+ result2 error
+ })
+ }
+ fake.getMultiplePrivateDataReturnsOnCall[i] = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultipleStates(arg1 ...string) ([][]byte, error) {
+ fake.getMultipleStatesMutex.Lock()
+ ret, specificReturn := fake.getMultipleStatesReturnsOnCall[len(fake.getMultipleStatesArgsForCall)]
+ fake.getMultipleStatesArgsForCall = append(fake.getMultipleStatesArgsForCall, struct {
+ arg1 []string
+ }{arg1})
+ stub := fake.GetMultipleStatesStub
+ fakeReturns := fake.getMultipleStatesReturns
+ fake.recordInvocation("GetMultipleStates", []interface{}{arg1})
+ fake.getMultipleStatesMutex.Unlock()
+ if stub != nil {
+ return stub(arg1...)
+ }
+ if specificReturn {
+ return ret.result1, ret.result2
+ }
+ return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesCallCount() int {
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
+ return len(fake.getMultipleStatesArgsForCall)
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesCalls(stub func(...string) ([][]byte, error)) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = stub
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesArgsForCall(i int) []string {
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
+ argsForCall := fake.getMultipleStatesArgsForCall[i]
+ return argsForCall.arg1
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesReturns(result1 [][]byte, result2 error) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = nil
+ fake.getMultipleStatesReturns = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesReturnsOnCall(i int, result1 [][]byte, result2 error) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = nil
+ if fake.getMultipleStatesReturnsOnCall == nil {
+ fake.getMultipleStatesReturnsOnCall = make(map[int]struct {
+ result1 [][]byte
+ result2 error
+ })
+ }
+ fake.getMultipleStatesReturnsOnCall[i] = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
func (fake *ChaincodeStub) GetPrivateData(arg1 string, arg2 string) ([]byte, error) {
fake.getPrivateDataMutex.Lock()
ret, specificReturn := fake.getPrivateDataReturnsOnCall[len(fake.getPrivateDataArgsForCall)]
@@ -3010,6 +3166,10 @@ func (fake *ChaincodeStub) Invocations() map[string][][]interface{} {
defer fake.getFunctionAndParametersMutex.RUnlock()
fake.getHistoryForKeyMutex.RLock()
defer fake.getHistoryForKeyMutex.RUnlock()
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
fake.getPrivateDataMutex.RLock()
defer fake.getPrivateDataMutex.RUnlock()
fake.getPrivateDataByPartialCompositeKeyMutex.RLock()
diff --git a/core/scc/qscc/mocks/chaincode_stub.go b/core/scc/qscc/mocks/chaincode_stub.go
index 68c1ce1d781..2498bfc29d5 100644
--- a/core/scc/qscc/mocks/chaincode_stub.go
+++ b/core/scc/qscc/mocks/chaincode_stub.go
@@ -148,6 +148,33 @@ type ChaincodeStub struct {
result1 shim.HistoryQueryIteratorInterface
result2 error
}
+ GetMultiplePrivateDataStub func(string, ...string) ([][]byte, error)
+ getMultiplePrivateDataMutex sync.RWMutex
+ getMultiplePrivateDataArgsForCall []struct {
+ arg1 string
+ arg2 []string
+ }
+ getMultiplePrivateDataReturns struct {
+ result1 [][]byte
+ result2 error
+ }
+ getMultiplePrivateDataReturnsOnCall map[int]struct {
+ result1 [][]byte
+ result2 error
+ }
+ GetMultipleStatesStub func(...string) ([][]byte, error)
+ getMultipleStatesMutex sync.RWMutex
+ getMultipleStatesArgsForCall []struct {
+ arg1 []string
+ }
+ getMultipleStatesReturns struct {
+ result1 [][]byte
+ result2 error
+ }
+ getMultipleStatesReturnsOnCall map[int]struct {
+ result1 [][]byte
+ result2 error
+ }
GetPrivateDataStub func(string, string) ([]byte, error)
getPrivateDataMutex sync.RWMutex
getPrivateDataArgsForCall []struct {
@@ -1213,6 +1240,135 @@ func (fake *ChaincodeStub) GetHistoryForKeyReturnsOnCall(i int, result1 shim.His
}{result1, result2}
}
+func (fake *ChaincodeStub) GetMultiplePrivateData(arg1 string, arg2 ...string) ([][]byte, error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ ret, specificReturn := fake.getMultiplePrivateDataReturnsOnCall[len(fake.getMultiplePrivateDataArgsForCall)]
+ fake.getMultiplePrivateDataArgsForCall = append(fake.getMultiplePrivateDataArgsForCall, struct {
+ arg1 string
+ arg2 []string
+ }{arg1, arg2})
+ stub := fake.GetMultiplePrivateDataStub
+ fakeReturns := fake.getMultiplePrivateDataReturns
+ fake.recordInvocation("GetMultiplePrivateData", []interface{}{arg1, arg2})
+ fake.getMultiplePrivateDataMutex.Unlock()
+ if stub != nil {
+ return stub(arg1, arg2...)
+ }
+ if specificReturn {
+ return ret.result1, ret.result2
+ }
+ return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataCallCount() int {
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ return len(fake.getMultiplePrivateDataArgsForCall)
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataCalls(stub func(string, ...string) ([][]byte, error)) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = stub
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataArgsForCall(i int) (string, []string) {
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ argsForCall := fake.getMultiplePrivateDataArgsForCall[i]
+ return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataReturns(result1 [][]byte, result2 error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = nil
+ fake.getMultiplePrivateDataReturns = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultiplePrivateDataReturnsOnCall(i int, result1 [][]byte, result2 error) {
+ fake.getMultiplePrivateDataMutex.Lock()
+ defer fake.getMultiplePrivateDataMutex.Unlock()
+ fake.GetMultiplePrivateDataStub = nil
+ if fake.getMultiplePrivateDataReturnsOnCall == nil {
+ fake.getMultiplePrivateDataReturnsOnCall = make(map[int]struct {
+ result1 [][]byte
+ result2 error
+ })
+ }
+ fake.getMultiplePrivateDataReturnsOnCall[i] = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultipleStates(arg1 ...string) ([][]byte, error) {
+ fake.getMultipleStatesMutex.Lock()
+ ret, specificReturn := fake.getMultipleStatesReturnsOnCall[len(fake.getMultipleStatesArgsForCall)]
+ fake.getMultipleStatesArgsForCall = append(fake.getMultipleStatesArgsForCall, struct {
+ arg1 []string
+ }{arg1})
+ stub := fake.GetMultipleStatesStub
+ fakeReturns := fake.getMultipleStatesReturns
+ fake.recordInvocation("GetMultipleStates", []interface{}{arg1})
+ fake.getMultipleStatesMutex.Unlock()
+ if stub != nil {
+ return stub(arg1...)
+ }
+ if specificReturn {
+ return ret.result1, ret.result2
+ }
+ return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesCallCount() int {
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
+ return len(fake.getMultipleStatesArgsForCall)
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesCalls(stub func(...string) ([][]byte, error)) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = stub
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesArgsForCall(i int) []string {
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
+ argsForCall := fake.getMultipleStatesArgsForCall[i]
+ return argsForCall.arg1
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesReturns(result1 [][]byte, result2 error) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = nil
+ fake.getMultipleStatesReturns = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
+func (fake *ChaincodeStub) GetMultipleStatesReturnsOnCall(i int, result1 [][]byte, result2 error) {
+ fake.getMultipleStatesMutex.Lock()
+ defer fake.getMultipleStatesMutex.Unlock()
+ fake.GetMultipleStatesStub = nil
+ if fake.getMultipleStatesReturnsOnCall == nil {
+ fake.getMultipleStatesReturnsOnCall = make(map[int]struct {
+ result1 [][]byte
+ result2 error
+ })
+ }
+ fake.getMultipleStatesReturnsOnCall[i] = struct {
+ result1 [][]byte
+ result2 error
+ }{result1, result2}
+}
+
func (fake *ChaincodeStub) GetPrivateData(arg1 string, arg2 string) ([]byte, error) {
fake.getPrivateDataMutex.Lock()
ret, specificReturn := fake.getPrivateDataReturnsOnCall[len(fake.getPrivateDataArgsForCall)]
@@ -3010,6 +3166,10 @@ func (fake *ChaincodeStub) Invocations() map[string][][]interface{} {
defer fake.getFunctionAndParametersMutex.RUnlock()
fake.getHistoryForKeyMutex.RLock()
defer fake.getHistoryForKeyMutex.RUnlock()
+ fake.getMultiplePrivateDataMutex.RLock()
+ defer fake.getMultiplePrivateDataMutex.RUnlock()
+ fake.getMultipleStatesMutex.RLock()
+ defer fake.getMultipleStatesMutex.RUnlock()
fake.getPrivateDataMutex.RLock()
defer fake.getPrivateDataMutex.RUnlock()
fake.getPrivateDataByPartialCompositeKeyMutex.RLock()
diff --git a/go.mod b/go.mod
index e15a3e1e407..9f3ef52417e 100644
--- a/go.mod
+++ b/go.mod
@@ -16,7 +16,7 @@ require (
github.com/gorilla/handlers v1.5.2
github.com/gorilla/mux v1.8.1
github.com/hyperledger-labs/SmartBFT v0.0.0-20241013183757-134292d4208a
- github.com/hyperledger/fabric-chaincode-go/v2 v2.1.0
+ github.com/hyperledger/fabric-chaincode-go/v2 v2.2.0
github.com/hyperledger/fabric-config v0.3.0
github.com/hyperledger/fabric-lib-go v1.1.3-0.20240523144151-25edd1eaf5f5
github.com/hyperledger/fabric-protos-go-apiv2 v0.3.6
diff --git a/go.sum b/go.sum
index 120702a177e..b04f1ca2ba8 100644
--- a/go.sum
+++ b/go.sum
@@ -887,8 +887,8 @@ github.com/hyperledger/aries-bbs-go v0.0.0-20240528084656-761671ea73bc h1:3Ykk6M
github.com/hyperledger/aries-bbs-go v0.0.0-20240528084656-761671ea73bc/go.mod h1:Kofn6A6WWea1ZM8Rys5aBW9dszwJ7Ywa0kyyYL0TPYw=
github.com/hyperledger/fabric-amcl v0.0.0-20230602173724-9e02669dceb2 h1:B1Nt8hKb//KvgGRprk0h1t4lCnwhE9/ryb1WqfZbV+M=
github.com/hyperledger/fabric-amcl v0.0.0-20230602173724-9e02669dceb2/go.mod h1:X+DIyUsaTmalOpmpQfIvFZjKHQedrURQ5t4YqquX7lE=
-github.com/hyperledger/fabric-chaincode-go/v2 v2.1.0 h1:/TwtyM32+YF743mShDUzO7UIBiwQ861y6Pm5lrfmeyM=
-github.com/hyperledger/fabric-chaincode-go/v2 v2.1.0/go.mod h1:ukM+tmj1jVLvjn3612EhDswaD3pz7i+YTZKcZCE0Erg=
+github.com/hyperledger/fabric-chaincode-go/v2 v2.2.0 h1:n7rgo7iYD4cCC2+NlyI2DwtP+hYLwUl5UKPcJi4IrM8=
+github.com/hyperledger/fabric-chaincode-go/v2 v2.2.0/go.mod h1:c3zA3gOL/V53a0v1TGgHe8nifeH6daG/UrmJs79I9pI=
github.com/hyperledger/fabric-config v0.3.0 h1:FS5/dc9GAniljP6RYxQRG92AaiBVoN2vTvtOvnWqeQs=
github.com/hyperledger/fabric-config v0.3.0/go.mod h1:kSevTn78K83Suc++JsEo7Nt1tYIPqDajW+ORz3OhWlg=
github.com/hyperledger/fabric-lib-go v1.1.3-0.20240523144151-25edd1eaf5f5 h1:RPWTL5wxAb+xDOrsCU3QYZP65305F8v3PaOyzdbPVMU=
diff --git a/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/handler.go b/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/handler.go
index 9c5fea72f42..346a15ac900 100644
--- a/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/handler.go
+++ b/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/handler.go
@@ -19,7 +19,8 @@ const (
established state = "established" // connection established
ready state = "ready" // ready for requests
- defaultMaxSizeWriteBatch = 100
+ defaultMaxSizeWriteBatch = 100
+ defaultMaxSizeGetMultipleKeys = 100
)
// PeerChaincodeStream is the common stream interface for Peer - chaincode communication.
@@ -51,6 +52,9 @@ type Handler struct {
// if you can send the changes in batches.
usePeerWriteBatch bool
maxSizeWriteBatch uint32
+ // if you can get the multiple keys in batches.
+ usePeerGetMultipleKeys bool
+ maxSizeGetMultipleKeys uint32
// Multiple queries (and one transaction) with different txids can be executing in parallel for this chaincode
// responseChannels is the channel on which responses are communicated by the shim to the chaincodeStub.
@@ -267,6 +271,80 @@ func (h *Handler) handleGetState(collection string, key string, channelID string
return nil, fmt.Errorf("[%s] incorrect chaincode message %s received. Expecting %s or %s", shorttxid(responseMsg.Txid), responseMsg.Type, peer.ChaincodeMessage_RESPONSE, peer.ChaincodeMessage_ERROR)
}
+// handleGetMultipleStates communicates with the peer to fetch the requested state information from the ledger.
+func (h *Handler) handleGetMultipleStates(collection string, keys []string, channelID string, txID string) ([][]byte, error) {
+ if len(keys) == 0 {
+ return nil, nil
+ }
+
+ responses := make([][]byte, 0, len(keys))
+
+ if !h.usePeerGetMultipleKeys {
+ for _, key := range keys {
+ resp, err := h.handleGetState(collection, key, channelID, txID)
+ if err != nil {
+ return nil, err
+ }
+ responses = append(responses, resp)
+ }
+ return responses, nil
+ }
+
+ for ; len(keys) > int(h.maxSizeGetMultipleKeys); keys = keys[h.maxSizeGetMultipleKeys:] {
+ resp, err := h.handleOneSendGetMultipleStates(collection, keys[:h.maxSizeGetMultipleKeys], channelID, txID)
+ if err != nil {
+ return nil, err
+ }
+ responses = append(responses, resp...)
+ }
+
+ if len(keys) > 0 {
+ resp, err := h.handleOneSendGetMultipleStates(collection, keys, channelID, txID)
+ if err != nil {
+ return nil, err
+ }
+ responses = append(responses, resp...)
+ }
+
+ for i := range responses {
+ if len(responses[i]) == 0 {
+ responses[i] = nil
+ }
+ }
+
+ return responses, nil
+}
+
+// handleOneSendGetMultipleStates communicates with the peer to fetch one batch of keys from the ledger.
+func (h *Handler) handleOneSendGetMultipleStates(collection string, keys []string, channelID string, txID string) ([][]byte, error) {
+ // Construct payload for GET_STATE_MULTIPLE
+ payloadBytes := marshalOrPanic(&peer.GetStateMultiple{Keys: keys, Collection: collection})
+
+ msg := &peer.ChaincodeMessage{Type: peer.ChaincodeMessage_GET_STATE_MULTIPLE, Payload: payloadBytes, Txid: txID, ChannelId: channelID}
+ responseMsg, err := h.callPeerWithChaincodeMsg(msg, channelID, txID)
+ if err != nil {
+ return nil, fmt.Errorf("[%s] error sending %s: %s", shorttxid(txID), peer.ChaincodeMessage_GET_STATE_MULTIPLE, err)
+ }
+
+ if responseMsg.Type == peer.ChaincodeMessage_RESPONSE {
+ // Success response
+ var gmkResult peer.GetStateMultipleResult
+ err = proto.Unmarshal(responseMsg.Payload, &gmkResult)
+ if err != nil {
+ return nil, errors.New("could not unmarshal get state multiple keys response")
+ }
+
+ return gmkResult.GetValues(), nil
+ }
+ if responseMsg.Type == peer.ChaincodeMessage_ERROR {
+ // Error response
+ return nil, fmt.Errorf("%s", responseMsg.Payload[:])
+ }
+
+ // Incorrect chaincode message received
+ return nil, fmt.Errorf("[%s] incorrect chaincode message %s received. Expecting %s or %s", shorttxid(responseMsg.Txid), responseMsg.Type, peer.ChaincodeMessage_RESPONSE, peer.ChaincodeMessage_ERROR)
+}
+
func (h *Handler) handleGetPrivateDataHash(collection string, key string, channelID string, txid string) ([]byte, error) {
// Construct payload for GET_PRIVATE_DATA_HASH
payloadBytes := marshalOrPanic(&peer.GetState{Collection: collection, Key: key})
@@ -733,6 +811,13 @@ func (h *Handler) handleEstablished(msg *peer.ChaincodeMessage) error {
h.maxSizeWriteBatch = defaultMaxSizeWriteBatch
}
+ h.usePeerGetMultipleKeys = ccAdditionalParams.UseGetMultipleKeys
+ h.maxSizeGetMultipleKeys = ccAdditionalParams.MaxSizeGetMultipleKeys
+
+ if h.usePeerGetMultipleKeys && h.maxSizeGetMultipleKeys < defaultMaxSizeGetMultipleKeys {
+ h.maxSizeGetMultipleKeys = defaultMaxSizeGetMultipleKeys
+ }
+
return nil
}
diff --git a/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/interfaces.go b/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/interfaces.go
index 27f9ba19308..66993fb82e8 100644
--- a/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/interfaces.go
+++ b/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/interfaces.go
@@ -80,6 +80,15 @@ type ChaincodeStubInterface interface {
// If the key does not exist in the state database, (nil, nil) is returned.
GetState(key string) ([]byte, error)
+ // GetMultipleStates retrieves the values of the specified keys from the ledger.
+ // It has similar semantics to the GetState function regarding read-your-own-writes behavior,
+ // meaning that updates made by a previous PutState operation within the same chaincode
+ // session are not visible to this function.
+ // If no key is passed, the function will return (nil, nil).
+ // GetMultipleStates returns values in the same order in which the keys are provided,
+ // and any keys missing from the ledger return a nil.
+ GetMultipleStates(keys ...string) ([][]byte, error)
+
// PutState puts the specified `key` and `value` into the transaction's
// writeset as a data-write proposal. PutState doesn't effect the ledger
// until the transaction is validated and successfully committed.
@@ -247,6 +256,15 @@ type ChaincodeStubInterface interface {
// that has not been committed.
GetPrivateData(collection, key string) ([]byte, error)
+ // GetMultiplePrivateData retrieves the values of the specified keys from the specified collection.
+ // It has similar semantics to the GetePrivateData function regarding read-your-own-writes behavior,
+ // meaning that updates made by a previous PutPrivateData operation within the same chaincode
+ // session are not visible to this function.
+ // If no key is passed, the function will return (nil, nil).
+ // GetMultiplePrivateData returns values in the same order in which the keys are provided,
+ // and any keys missing from the ledger return a nil.
+ GetMultiplePrivateData(collection string, keys ...string) ([][]byte, error)
+
// GetPrivateDataHash returns the hash of the value of the specified `key` from the specified
// `collection`
GetPrivateDataHash(collection, key string) ([]byte, error)
diff --git a/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/stub.go b/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/stub.go
index 6655d14fbd7..2553f2429e7 100644
--- a/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/stub.go
+++ b/vendor/github.com/hyperledger/fabric-chaincode-go/v2/shim/stub.go
@@ -166,6 +166,13 @@ func (s *ChaincodeStub) GetState(key string) ([]byte, error) {
return s.handler.handleGetState(collection, key, s.ChannelID, s.TxID)
}
+// GetMultipleStates documentation can be found in interfaces.go
+func (s *ChaincodeStub) GetMultipleStates(keys ...string) ([][]byte, error) {
+ // Access public data by setting the collection to empty string
+ collection := ""
+ return s.handler.handleGetMultipleStates(collection, keys, s.ChannelID, s.TxID)
+}
+
// SetStateValidationParameter documentation can be found in interfaces.go
func (s *ChaincodeStub) SetStateValidationParameter(key string, ep []byte) error {
return s.putStateMetadataEntry("", key, s.validationParameterMetakey, ep)
@@ -262,6 +269,14 @@ func (s *ChaincodeStub) GetPrivateData(collection string, key string) ([]byte, e
return s.handler.handleGetState(collection, key, s.ChannelID, s.TxID)
}
+// GetMultiplePrivateData documentation can be found in interfaces.go
+func (s *ChaincodeStub) GetMultiplePrivateData(collection string, keys ...string) ([][]byte, error) {
+ if collection == "" {
+ return nil, fmt.Errorf("collection must not be an empty string")
+ }
+ return s.handler.handleGetMultipleStates(collection, keys, s.ChannelID, s.TxID)
+}
+
// GetPrivateDataHash documentation can be found in interfaces.go
func (s *ChaincodeStub) GetPrivateDataHash(collection string, key string) ([]byte, error) {
if collection == "" {
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 5bcc8664794..8abe6a2b04c 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -216,7 +216,7 @@ github.com/hyperledger/fabric-amcl/amcl
github.com/hyperledger/fabric-amcl/amcl/FP256BN
github.com/hyperledger/fabric-amcl/core
github.com/hyperledger/fabric-amcl/core/FP256BN
-# github.com/hyperledger/fabric-chaincode-go/v2 v2.1.0
+# github.com/hyperledger/fabric-chaincode-go/v2 v2.2.0
## explicit; go 1.22.0
github.com/hyperledger/fabric-chaincode-go/v2/pkg/statebased
github.com/hyperledger/fabric-chaincode-go/v2/shim