@@ -11,6 +11,7 @@ import (
1111 "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
1212 "github.com/hyperledger-labs/fabric-token-sdk/token/core/common/encoding/asn1"
1313 math2 "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/math"
14+ executor "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/rp/executor"
1415)
1516
1617// RangeCorrectness contains a set of range proofs for multiple commitments.
@@ -80,17 +81,27 @@ type RangeCorrectnessProver struct {
8081 // Curve is the mathematical curve.
8182 Curve * math.Curve
8283 TranscriptHeader []byte
84+ // Provider creates a fresh Executor for each Prove call.
85+ // If nil, executor.DefaultProvider (SerialProvider) is used.
86+ Provider executor.ExecutorProvider
8387}
8488
8589// NewRangeCorrectnessProver returns a new RangeCorrectnessProver instance.
90+ // provider controls how independent range proofs are executed; pass nil
91+ // to use SerialProvider, which preserves the previous serial behaviour.
8692func NewRangeCorrectnessProver (
8793 coms []* math.G1 ,
8894 values []uint64 ,
8995 blindingFactors []* math.Zr ,
9096 pedersenParameters , leftGenerators , rightGenerators []* math.G1 ,
9197 bitLength uint64 ,
9298 c * math.Curve ,
99+ provider executor.ExecutorProvider ,
93100) * RangeCorrectnessProver {
101+ if provider == nil {
102+ provider = executor .DefaultProvider
103+ }
104+
94105 return & RangeCorrectnessProver {
95106 Commitments : coms ,
96107 Values : values ,
@@ -100,32 +111,49 @@ func NewRangeCorrectnessProver(
100111 RightGenerators : rightGenerators ,
101112 BitLength : bitLength ,
102113 Curve : c ,
114+ Provider : provider ,
103115 }
104116}
105117
106- // Prove generates a set of range proofs.
118+ // Prove generates a set of range proofs, one per commitment.
119+ // Independent proofs are executed using the Provider's Executor strategy.
107120func (p * RangeCorrectnessProver ) Prove () (* RangeCorrectness , error ) {
108121 if len (p .TranscriptHeader ) == 0 {
109122 return nil , errors .New ("transcript header is empty" )
110123 }
111- rc := & RangeCorrectness {}
112- rc .Proofs = make ([]* RangeProof , len (p .Commitments ))
113- for i := range len (p .Commitments ) {
114- bp := NewRangeProver (
115- p .Commitments [i ],
116- math2 .NewCachedZrFromInt (p .Curve , p .Values [i ]),
117- p .BlindingFactors [i ],
118- p .PedersenParameters ,
119- p .LeftGenerators ,
120- p .RightGenerators ,
121- p .BitLength ,
122- p .Curve ,
123- ).WithTranscriptHeader (p .TranscriptHeader )
124- proof , err := bp .Prove ()
124+
125+ n := len (p .Commitments )
126+ rc := & RangeCorrectness {
127+ Proofs : make ([]* RangeProof , n ),
128+ }
129+ errs := make ([]error , n )
130+
131+ // A fresh Executor is obtained per Prove call so that concurrent callers
132+ // on the same RangeCorrectnessProver never share an Executor instance.
133+ exec := p .Provider .New ()
134+
135+ for i := range n {
136+ exec .Submit (func () {
137+ bp := NewRangeProver (
138+ p .Commitments [i ],
139+ math2 .NewCachedZrFromInt (p .Curve , p .Values [i ]),
140+ p .BlindingFactors [i ],
141+ p .PedersenParameters ,
142+ p .LeftGenerators ,
143+ p .RightGenerators ,
144+ p .BitLength ,
145+ p .Curve ,
146+ ).WithTranscriptHeader (p .TranscriptHeader )
147+ rc .Proofs [i ], errs [i ] = bp .Prove ()
148+ })
149+ }
150+
151+ exec .Wait ()
152+
153+ for _ , err := range errs {
125154 if err != nil {
126155 return nil , err
127156 }
128- rc .Proofs [i ] = proof
129157 }
130158
131159 return rc , nil
@@ -150,47 +178,77 @@ type RangeCorrectnessVerifier struct {
150178 // BitLength is the maximum bit length of the values.
151179 BitLength uint64
152180 // Curve is the mathematical curve.
153- Curve * math.Curve
154-
181+ Curve * math.Curve
155182 TranscriptHeader []byte
183+ // Provider creates a fresh Executor for each Verify call.
184+ // If nil, executor.DefaultProvider (SerialProvider) is used.
185+ Provider executor.ExecutorProvider
156186}
157187
158188// NewRangeCorrectnessVerifier returns a new RangeCorrectnessVerifier instance.
189+ // provider controls how independent range proofs are verified; pass nil
190+ // to use SerialProvider, which preserves the previous serial behaviour.
159191func NewRangeCorrectnessVerifier (
160192 pedersenParameters , leftGenerators , rightGenerators []* math.G1 ,
161193 bitLength uint64 ,
162194 curve * math.Curve ,
195+ provider executor.ExecutorProvider ,
163196) * RangeCorrectnessVerifier {
197+ if provider == nil {
198+ provider = executor .DefaultProvider
199+ }
200+
164201 return & RangeCorrectnessVerifier {
165202 PedersenParameters : pedersenParameters ,
166203 LeftGenerators : leftGenerators ,
167204 RightGenerators : rightGenerators ,
168205 BitLength : bitLength ,
169206 Curve : curve ,
207+ Provider : provider ,
170208 }
171209}
172210
173211// Verify checks if the provided set of range proofs is valid.
212+ // Independent proofs are verified using the Provider's Executor strategy.
174213func (v * RangeCorrectnessVerifier ) Verify (rc * RangeCorrectness ) error {
175214 if len (rc .Proofs ) != len (v .Commitments ) {
176215 return errors .New ("invalid range proof" )
177216 }
178217 if len (v .TranscriptHeader ) == 0 {
179218 return errors .New ("transcript header is empty" )
180219 }
181- for i := range len (rc .Proofs ) {
182- if rc .Proofs [i ] == nil {
183- return errors .Errorf ("invalid range proof: nil proof at index %d" , i )
184- }
185- bv := NewRangeVerifier (
186- v .PedersenParameters ,
187- v .LeftGenerators ,
188- v .RightGenerators ,
189- v .Commitments [i ],
190- v .BitLength ,
191- v .Curve ,
192- ).WithTranscriptHeader (v .TranscriptHeader )
193- err := bv .Verify (rc .Proofs [i ])
220+
221+ n := len (rc .Proofs )
222+ errs := make ([]error , n )
223+
224+ // A fresh Executor is obtained per Verify call so that concurrent callers
225+ // on the same RangeCorrectnessVerifier never share an Executor instance.
226+ exec := v .Provider .New ()
227+
228+ for i := range n {
229+ exec .Submit (func () {
230+ if rc .Proofs [i ] == nil {
231+ errs [i ] = errors .Errorf ("invalid range proof: nil proof at index %d" , i )
232+
233+ return
234+ }
235+
236+ bv := NewRangeVerifier (
237+ v .PedersenParameters ,
238+ v .LeftGenerators ,
239+ v .RightGenerators ,
240+ v .Commitments [i ],
241+ v .BitLength ,
242+ v .Curve ,
243+ ).WithTranscriptHeader (v .TranscriptHeader )
244+
245+ errs [i ] = bv .Verify (rc .Proofs [i ])
246+ })
247+ }
248+
249+ exec .Wait ()
250+
251+ for i , err := range errs {
194252 if err != nil {
195253 return errors .Wrapf (err , "invalid range proof at index %d" , i )
196254 }
0 commit comments