Documentation
¶
Overview ¶
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Package bulletproofs Copyright 2024 Distributed Lab. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Index ¶
- func HexMapping(digits []*big.Int) []*big.Int
- func MustRandPoint() *bn256.G1
- func MustRandScalar() *big.Int
- func UInt64Hex(x uint64) []*big.Int
- func VerifyCircuit(public *ArithmeticCircuitPublic, V []*bn256.G1, fs FiatShamirEngine, ...) error
- func VerifyRange(public *ReciprocalPublic, V *bn256.G1, fs FiatShamirEngine, ...) error
- func VerifyWNLA(public *WeightNormLinearPublic, proof *WeightNormLinearArgumentProof, ...) error
- type ArithmeticCircuitPrivate
- type ArithmeticCircuitProof
- type ArithmeticCircuitPublic
- type FiatShamirEngine
- type KeccakFS
- type PartitionF
- type PartitionType
- type ReciprocalPrivate
- type ReciprocalProof
- type ReciprocalPublic
- type WeightNormLinearArgumentProof
- type WeightNormLinearPublic
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func MustRandPoint ¶
func MustRandScalar ¶
func VerifyCircuit ¶
func VerifyCircuit(public *ArithmeticCircuitPublic, V []*bn256.G1, fs FiatShamirEngine, proof *ArithmeticCircuitProof) error
VerifyCircuit verifies BP++ arithmetic circuit zero-knowledge proof using WNLA protocol. If err is nil then proof is valid. Use empty FiatShamirEngine for call.
func VerifyRange ¶
func VerifyRange(public *ReciprocalPublic, V *bn256.G1, fs FiatShamirEngine, proof *ReciprocalProof) error
VerifyRange verifies BP++ reciprocal argument range proof on arithmetic circuits. If err is nil then proof is valid. Use empty FiatShamirEngine for call.
func VerifyWNLA ¶
func VerifyWNLA(public *WeightNormLinearPublic, proof *WeightNormLinearArgumentProof, Com *bn256.G1, fs FiatShamirEngine) error
VerifyWNLA verifies the weight norm linear argument proof. If err is nil then proof is valid. Use empty FiatShamirEngine for call. Also, use the same commitment that has been used during proving.
Types ¶
type ArithmeticCircuitProof ¶
type ArithmeticCircuitProof struct {
CL, CR, CO, CS *bn256.G1
WNLA *WeightNormLinearArgumentProof
}
func ProveCircuit ¶
func ProveCircuit(public *ArithmeticCircuitPublic, V []*bn256.G1, fs FiatShamirEngine, private *ArithmeticCircuitPrivate) *ArithmeticCircuitProof
ProveCircuit generates zero knowledge proof that witness satisfies BP++ arithmetic circuit. Use empty FiatShamirEngine for call.
type ArithmeticCircuitPublic ¶
type ArithmeticCircuitPublic struct {
Nm, Nl, Nv, Nw, No int // Nw = Nm + Nm + No (for L, R, O parts), Nl = Nv * K
K int // Count of witness vectors v.
G *bn256.G1
GVec []*bn256.G1 // Nm
HVec []*bn256.G1 // Nv+9
Wm [][]*big.Int // Nm * Nw
Wl [][]*big.Int // Nl * Nw
Am []*big.Int // Nm
Al []*big.Int // Nl
Fl bool
Fm bool
F PartitionF
// Vectors of points that will be used in WNLA protocol
GVec_ []*bn256.G1 // 2^n - Nm
HVec_ []*bn256.G1 // 2^n - (Nv+9)
}
func (*ArithmeticCircuitPublic) CommitCircuit ¶
CommitCircuit creates a commitment for v vector and blinding s. Com = v[0]*G + s*H[0] + <v[1:], H[9:]>
type FiatShamirEngine ¶
func NewKeccakFS ¶
func NewKeccakFS() FiatShamirEngine
type KeccakFS ¶
type KeccakFS struct {
// contains filtered or unexported fields
}
func (*KeccakFS) GetChallenge ¶
type PartitionF ¶
type PartitionF = func(typ PartitionType, index int) *int
type PartitionType ¶
type PartitionType int
const ( PartitionLO PartitionType = iota PartitionLL PartitionLR PartitionNO )
type ReciprocalPrivate ¶
type ReciprocalProof ¶
type ReciprocalProof struct { *ArithmeticCircuitProof V *bn256.G1 }
func ProveRange ¶
func ProveRange(public *ReciprocalPublic, fs FiatShamirEngine, private *ReciprocalPrivate) *ReciprocalProof
ProveRange generates zero knowledge proof that corresponding to the committed digits vector value lies in [0, 2^n) range. Use empty FiatShamirEngine for call.
type ReciprocalPublic ¶
type ReciprocalPublic struct { G *bn256.G1 GVec []*bn256.G1 // Nm HVec []*bn256.G1 // Nv+9 Nd, Np int // Vectors of points that will be used in WNLA protocol GVec_ []*bn256.G1 // 2^n - Nm HVec_ []*bn256.G1 // 2^n - (Nv+9) }
ReciprocalPublic dimensions: Nd - count of private proles (size of committed value), Np - count of public poles (number system base). Nm = Nd, No = Np Nv = 1 + Nd G and HVec[0] will be used for the value commitment: VCom = value*G + blinding*HVec[0]
func (*ReciprocalPublic) CommitPoles ¶
func (*ReciprocalPublic) CommitValue ¶
type WeightNormLinearArgumentProof ¶
WeightNormLinearArgumentProof contains the proof of knowledge of vectors L, N for corresponding commitment C (is not included into the proof structure).
func ProveWNLA ¶
func ProveWNLA(public *WeightNormLinearPublic, Com *bn256.G1, fs FiatShamirEngine, l, n []*big.Int) *WeightNormLinearArgumentProof
ProveWNLA generates zero knowledge proof of knowledge of two vectors l and n that satisfies the commitment C (see WeightNormLinearPublic.Commit() function). Use empty FiatShamirEngine for call.
type WeightNormLinearPublic ¶
type WeightNormLinearPublic struct { G *bn256.G1 GVec, HVec []*bn256.G1 C []*big.Int Ro, Mu *big.Int // mu = ro^2 }
WeightNormLinearPublic contains the public values to be used in weight norm linear argument proof. The GVec and HVec sizes are recommended to be a powers of 2 and equal to the `n` and `l` private vector sizes.
func NewWeightNormLinearPublic ¶
func NewWeightNormLinearPublic(lLen int, nLen int) *WeightNormLinearPublic
func (*WeightNormLinearPublic) CommitWNLA ¶
CommitWNLA creates a commitment for vectors n, l based on public parameters p. Commit(l, n) = v*G + <l, H> + <n, G> where v = <c, l> + |n^2|_mu