├── Circuitcompiler
├── Programm.go
├── Programm_test.go
├── R1CS.go
├── circuit.go
├── circuit_test.go
├── client.go
├── factorHandling.go
├── factorHandling_test.go
├── gate.go
├── gateContainer.go
├── hub.go
├── lexer.go
├── lexer_test.go
├── parser.go
├── parser_test.go
├── rune_stack.go
├── server.go
├── visualizer.go
├── visualizer_test.go
├── web_g6
│ ├── favicon.ico
│ ├── g6.min.js
│ ├── index.html
│ └── index.js
└── web_vivagraph
│ ├── favicon.ico
│ ├── index.html
│ ├── index.js
│ └── vivagraph.js
├── LICENSE
├── README.md
├── main.go
├── pairing
├── bn256.go
├── bn256_test.go
├── constants.go
├── curve.go
├── example_test.go
├── gfp12.go
├── gfp2.go
├── gfp6.go
├── main_test.go
├── optate.go
└── twist.go
├── testPrograms
└── codes.go
├── utils
├── avl.go
├── fft.go
├── fft_test.go
├── finiteField.go
├── finiteField_test.go
├── parallelize.go
├── polynomialField.go
├── polynomialField_test.go
├── sparsePolynomial.go
├── sparsePolynomial_test.go
├── utils.go
└── utils_test.go
└── zkSNARK
├── groth16.go
└── groth16_test.go
/Circuitcompiler/Programm_test.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "fmt"
5 | "github.com/mottla/go-R1CS-Compiler/testPrograms"
6 | "github.com/mottla/go-R1CS-Compiler/utils"
7 | "github.com/stretchr/testify/assert"
8 | "math/big"
9 | "testing"
10 | )
11 |
12 | func TestStaticIfProgram(t *testing.T) {
13 | code := `
14 | func main(x field,y field)(field) {
15 | if 2>3 {
16 | return x*x
17 | }
18 | if 2>3 {
19 | return y*y
20 | }else if 5!=5{
21 | return x*x*x
22 | }else if 5==5{
23 | x=y*y
24 | }
25 | return x*x
26 | }
27 |
28 | `
29 | p := Parse(code)
30 | container := p.Execute()
31 |
32 | gates := container.OrderedGates()
33 | fmt.Println("\n generating R1CS")
34 | r1cs := p.GatesToR1CS(gates)
35 | fmt.Printf("number of gates %v, witness length %v \n ", r1cs.NumberOfGates, r1cs.WitnessLength)
36 | //
37 | fmt.Println(r1cs.L)
38 | fmt.Println(r1cs.R)
39 | fmt.Println(r1cs.O)
40 | }
41 |
42 | func TestArrayProgram(t *testing.T) {
43 | code := `
44 | func main(x bool,z field) (field) {
45 | var caa = [2]field{33,44}
46 | var ca = [2][2]field{ caa, [2]field{55,44}}
47 | z = z*ca[1][1]
48 | ca[1][1] = 66
49 | z = z*ca[1][1]
50 | z = z*z
51 | return z
52 | }
53 | `
54 | program := Parse(code)
55 | container := program.Execute()
56 |
57 | gates := container.OrderedGates()
58 | fmt.Println("\n generating R1CS")
59 | r1cs := program.GatesToR1CS(gates)
60 | fmt.Printf("number of gates %v, witness length %v \n ", r1cs.NumberOfGates, r1cs.WitnessLength)
61 | //
62 | fmt.Println(r1cs.L)
63 | fmt.Println(r1cs.R)
64 | fmt.Println(r1cs.O)
65 | inputs := CombineInputs(program.GetMainCircuit().InputIdentifiers, []*big.Int{big.NewInt(int64(27)), big.NewInt(int64(27))})
66 |
67 | fmt.Println("input")
68 | fmt.Println(inputs)
69 |
70 | w, err := CalculateTrace(r1cs, inputs)
71 | assert.NoError(t, err)
72 | fmt.Printf("witness len %v \n ", len(w))
73 | fmt.Println(w)
74 | }
75 |
76 | func TestForProgram(t *testing.T) {
77 | code := `
78 | func main(x field,z field,y func(x bool)(bool))(func(a field)(bool)) {
79 | #x,z = test()
80 | var c = 5
81 | var mul5 = mul(5)
82 | x = mul5(square(x))
83 | x = (square(x)-1)*square(x)
84 | x = (square(x)-1)*square(x)
85 | return func(a field)(bool) { return true }
86 | }
87 | func a()(func(c bool)(bool)) {
88 | return func(a bool)(bool){return true}
89 | }
90 | func square(x field)(field){ return x*x }
91 | func mul(a field,b field)(field){return b*a }
92 | func test()(bool,field){
93 | return true,3
94 | }
95 | `
96 | program := Parse(code)
97 | container := program.Execute()
98 |
99 | gates := container.OrderedGates()
100 | fmt.Println("\n generating R1CS")
101 | r1cs := program.GatesToR1CS(gates)
102 | fmt.Printf("number of gates %v, witness length %v \n ", r1cs.NumberOfGates, r1cs.WitnessLength)
103 | //
104 | fmt.Println(r1cs.L)
105 | fmt.Println(r1cs.R)
106 | fmt.Println(r1cs.O)
107 | inputs := CombineInputs(program.GetMainCircuit().InputIdentifiers, []*big.Int{big.NewInt(int64(3)), big.NewInt(int64(5)), big.NewInt(int64(7))})
108 |
109 | fmt.Println("input")
110 | fmt.Println(inputs)
111 |
112 | w, err := CalculateTrace(r1cs, inputs)
113 | assert.NoError(t, err)
114 | fmt.Printf("witness len %v \n ", len(w))
115 | fmt.Println(w)
116 | }
117 |
118 | func TestFibonacciPrograms(t *testing.T) {
119 | for _, test := range testPrograms.TestFibonacci {
120 | if test.Skip {
121 | continue
122 | }
123 |
124 | fmt.Println("\n unreduced")
125 | utils.PrintWithLineNumbering(test.Code)
126 | program := Parse(test.Code)
127 |
128 | container := program.Execute()
129 | gates := container.OrderedGates()
130 | fmt.Println("\n generating R1CS")
131 | r1cs := program.GatesToR1CS(gates)
132 | fmt.Printf("number of gates %v, witness length %v \n ", r1cs.NumberOfGates, r1cs.WitnessLength)
133 | //
134 | fmt.Println(r1cs.L)
135 | fmt.Println(r1cs.R)
136 | fmt.Println(r1cs.O)
137 |
138 | for _, io := range test.IO {
139 | inputs := CombineInputs(program.GetMainCircuit().InputIdentifiers, io.Inputs)
140 |
141 | fmt.Println("input")
142 | fmt.Println(inputs)
143 |
144 | w, err := CalculateTrace(r1cs, inputs)
145 | assert.NoError(t, err)
146 | fmt.Printf("witness len %v \n ", len(w))
147 | fmt.Println(w)
148 |
149 | }
150 | }
151 | }
152 |
153 | func TestSudokuPrograms(t *testing.T) {
154 |
155 | for _, test := range testPrograms.TestSudoku {
156 | if test.Skip {
157 | continue
158 | }
159 |
160 | fmt.Println("\n unreduced")
161 | utils.PrintWithLineNumbering(test.Code)
162 | program := Parse(test.Code)
163 |
164 | container := program.Execute()
165 | gates := container.OrderedGates()
166 | fmt.Println("\n generating R1CS")
167 | r1cs := program.GatesToR1CS(gates)
168 | fmt.Printf("number of gates %v, witness length %v \n ", r1cs.NumberOfGates, r1cs.WitnessLength)
169 | //
170 | //fmt.Println(r1cs.L)
171 | //fmt.Println(r1cs.R)
172 | //fmt.Println(r1cs.O)
173 |
174 | for _, io := range test.IO {
175 | strs := []string{}
176 | ArrayStringBuild([]int64{9, 9}, "sudoku", &strs)
177 |
178 | inputs := CombineInputs(strs, io.Inputs)
179 |
180 | fmt.Println("input")
181 | fmt.Println(inputs)
182 |
183 | w, err := CalculateTrace(r1cs, inputs)
184 | assert.NoError(t, err)
185 | fmt.Printf("witness len %v \n ", len(w))
186 | fmt.Println(w)
187 |
188 | }
189 | }
190 | }
191 |
192 | //seems to have trouble when the field size is to small
193 | //func TestFixedBaseExponentiation(t *testing.T) {
194 | //
195 | // var codeGen = func(exponent string) string {
196 | // return fmt.Sprintf(`
197 | // func main( x) {
198 | // public{
199 | // x
200 | // }
201 | // return x**%v
202 | // }
203 | //
204 | //`, exponent)
205 | // }
206 | //
207 | // for i := 0; i < 10; i++ {
208 | // exponent, _ := utils.Field.ArithmeticField.Rand()
209 | // code := codeGen(exponent.String())
210 | //
211 | // program := Parse(code, true)
212 | //
213 | // container := program.Execute()
214 | // gates := container.OrderedGates()
215 | // r1cs := program.GatesToR1CS(gates)
216 | // for j := 0; j < 10; j++ {
217 | // base, _ := utils.Field.ArithmeticField.Rand()
218 | // expected := utils.Field.ArithmeticField.Exp(base, exponent)
219 | // inputs := CombineInputs(program.GetMainCircuit().InputIdentifiers, []*big.Int{base})
220 | // w, err := CalculateTrace(r1cs, inputs)
221 | // assert.NoError(t, err)
222 | // assert.Equal(t, w[len(w)-1], expected)
223 | // }
224 | // }
225 | //
226 | //}
227 |
--------------------------------------------------------------------------------
/Circuitcompiler/R1CS.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "errors"
5 | "fmt"
6 | "github.com/mottla/go-R1CS-Compiler/utils"
7 | "math/big"
8 | )
9 |
10 | type R1CS struct {
11 | //indexMap maps each variable to its position in the witness trace
12 | indexMap map[string]int
13 | WitnessLength, NumberOfGates int
14 | //splitMap maps each variable (which is split into its bit represants at some point in the code) onto the positions
15 | //of the its bits in the indexMap
16 | splitmap map[string][]int
17 | L []utils.Poly
18 | R []utils.Poly
19 | O []utils.Poly
20 | triggers []func(witness *[]*big.Int, set utils.FastBool, indexMap map[string]int) bool
21 | }
22 | type R1CSSparse struct {
23 | indexMap map[string]int
24 | splitmap map[string][]int
25 | WitnessLength, NumberOfGates int
26 | L []*utils.AvlTree
27 | R []*utils.AvlTree
28 | O []*utils.AvlTree
29 | }
30 | type R1CSsPARSETransposed struct {
31 | indexMap map[string]int
32 | WitnessLength, NumberOfGates int
33 | L []*utils.AvlTree
34 | R []*utils.AvlTree
35 | O []*utils.AvlTree
36 | }
37 | type R1CSTransposed struct {
38 | indexMap map[string]int
39 | WitnessLength, NumberOfGates int
40 | L []utils.Poly
41 | R []utils.Poly
42 | O []utils.Poly
43 | }
44 |
45 | func (er1cs *R1CSSparse) TransposeSparse() (transposed *R1CSsPARSETransposed) {
46 | transposed = &R1CSsPARSETransposed{}
47 | transposed.indexMap = er1cs.indexMap
48 | transposed.NumberOfGates = er1cs.NumberOfGates
49 | transposed.WitnessLength = er1cs.WitnessLength
50 |
51 | transposed.L = utils.TransposeSparse(er1cs.L, er1cs.WitnessLength)
52 | transposed.R = utils.TransposeSparse(er1cs.R, er1cs.WitnessLength)
53 | transposed.O = utils.TransposeSparse(er1cs.O, er1cs.WitnessLength)
54 |
55 | return
56 | }
57 |
58 | func (er1cs *R1CS) Transpose() (transposed *R1CSTransposed) {
59 | transposed = &R1CSTransposed{}
60 | transposed.indexMap = er1cs.indexMap
61 | transposed.NumberOfGates = er1cs.NumberOfGates
62 | transposed.WitnessLength = er1cs.WitnessLength
63 | transposed.L = utils.Transpose(er1cs.L)
64 | transposed.R = utils.Transpose(er1cs.R)
65 | transposed.O = utils.Transpose(er1cs.O)
66 | return
67 | }
68 |
69 | func (er1cs *R1CSTransposed) R1CSToEAP_FFT(fft *utils.FFT_PrecomputedParas, pf *utils.PolynomialField, tau *big.Int) (Ai_Tau, Ri_Tau, Oi_Tau []*big.Int) {
70 |
71 | lT := er1cs.L
72 | rT := er1cs.R
73 | oT := er1cs.O
74 |
75 | gates := fft.Size
76 | lagreangeBasesAtTau := make(utils.Poly, er1cs.NumberOfGates)
77 | zeta := pf.EvalPoly(fft.Domain, tau)
78 |
79 | lambda := pf.F.Div(zeta, new(big.Int).SetInt64(int64(gates)))
80 | rho := fft.RootOfUnitys[0]
81 |
82 | lagreangeBasesAtTau[0] = pf.F.Div(lambda, pf.F.Sub(tau, rho))
83 |
84 | for i := 1; i < er1cs.NumberOfGates; i++ {
85 | lambda = pf.F.Mul(lambda, fft.RootOfUnity)
86 | index := ((gates >> 1) + i) % gates
87 | //inv,_ := pf.Div(utils.Poly{bigOne},utils.Poly{fft.RootOfUnitys[ index], bigOne})
88 | lagreangeBasesAtTau[i] = pf.F.Div(lambda, pf.F.Add(fft.RootOfUnitys[index], tau))
89 | }
90 | Ai_Tau, Ri_Tau, Oi_Tau = make([]*big.Int, er1cs.WitnessLength), make([]*big.Int, er1cs.WitnessLength), make([]*big.Int, er1cs.WitnessLength)
91 |
92 | for i := 0; i < er1cs.WitnessLength; i++ {
93 | Ai_Tau[i] = pf.F.ScalarProduct(lT[i], lagreangeBasesAtTau)
94 |
95 | Ri_Tau[i] = pf.F.ScalarProduct(rT[i], lagreangeBasesAtTau)
96 |
97 | Oi_Tau[i] = pf.F.ScalarProduct(oT[i], lagreangeBasesAtTau)
98 | }
99 | return
100 | }
101 |
102 | ////note that invDFFT and DFFT increase the size of the input array to the next power of two
103 | //func (er1cs *R1CSTransposed) R1CSToEAP_FFT(fft *utils.FFT_PrecomputedParas) (lPoly, rPoly, oPoly []utils.Poly) {
104 | //
105 | // pf := utils.Field.PolynomialField
106 | //
107 | // lT := er1cs.L
108 | // rT := er1cs.R
109 | // oT := er1cs.O
110 | // gates := fft.Size
111 | // lagreangeBases := make([]utils.Poly, gates)
112 | // invGateNumber := pf.F.Inverse(new(big.Int).SetInt64(int64(gates)))
113 | // lambda := pf.MulScalar(fft.Domain, invGateNumber)
114 | // rho := fft.RootOfUnitys[gates>>1]
115 | // var rest utils.Poly
116 | // lagreangeBases[0], rest = pf.Div(lambda, utils.Poly{rho, bigOne})
117 | // if !utils.IsZeroArray(rest) {
118 | // panic("no rest")
119 | // }
120 | //
121 | // for i := 1; i < gates; i++ {
122 | // lambda = pf.MulScalar(lambda, fft.RootOfUnity)
123 | // index := ((gates >> 1) + i) % gates
124 | // //inv,_ := pf.Div(utils.Poly{bigOne},utils.Poly{fft.RootOfUnitys[ index], bigOne})
125 | // lagreangeBases[i], _ = pf.Div(lambda, utils.Poly{fft.RootOfUnitys[index], bigOne})
126 | // }
127 | //
128 | // for i := 0; i < er1cs.WitnessLength; i++ {
129 | //
130 | // lPoly = append(lPoly, pf.AddPolynomials(pf.LinearCombine(lagreangeBases, lT[i])))
131 | //
132 | // rPoly = append(rPoly, pf.AddPolynomials(pf.LinearCombine(lagreangeBases, rT[i])))
133 | //
134 | // oPoly = append(oPoly, pf.AddPolynomials(pf.LinearCombine(lagreangeBases, oT[i])))
135 | // }
136 | // return
137 | //}
138 |
139 | func CalculateTrace(r1cs *R1CS, input []InputArgument) (witness []*big.Int, err error) {
140 |
141 | witness = utils.ArrayOfBigZeros(len(r1cs.indexMap))
142 | set := utils.NewFastBool()
143 |
144 | invIndexMap := make(map[int]string)
145 | for k, v := range r1cs.indexMap {
146 | invIndexMap[v] = k
147 | }
148 |
149 | var setWitness = func(index int, value *big.Int) {
150 | witness[index] = utils.Field.ArithmeticField.Affine(value)
151 | set.Set(index)
152 |
153 | //go over the list of self triggering funktions
154 | var remain []func(witness *[]*big.Int, set utils.FastBool, indexMap map[string]int) bool
155 | for i := 0; i < len(r1cs.triggers); i++ {
156 | //we evaluate the trigger function. if it detects, that all values are there it
157 | //needs to compute some values, it does so, and returns true.
158 | //from then on, we dont need it anymore and throw it away
159 | if !(r1cs.triggers[i])(&witness, set, r1cs.indexMap) {
160 | remain = append(remain, r1cs.triggers[i])
161 | }
162 | }
163 | r1cs.triggers = remain
164 |
165 | }
166 | setWitness(0, big.NewInt(int64(1)))
167 |
168 | for _, v := range input {
169 | setWitness(r1cs.indexMap[v.identifier], v.value)
170 | }
171 |
172 | zero := big.NewInt(int64(0))
173 |
174 | getKnownsAndUnknowns := func(array []*big.Int) (knowns []*big.Int, unknownsAtIndices []int) {
175 |
176 | knowns = utils.ArrayOfBigZeros(len(array))
177 | for j, val := range array {
178 | if val.Cmp(zero) != 0 {
179 | if !set.IsSet(j) {
180 | unknownsAtIndices = append(unknownsAtIndices, j)
181 | } else {
182 | knowns[j] = val
183 | }
184 | }
185 | }
186 | return
187 | }
188 |
189 | sum := func(array []*big.Int) *big.Int {
190 | return utils.Field.ArithmeticField.ScalarProduct(array, witness)
191 | }
192 |
193 | for i := 0; i < len(r1cs.L); i++ {
194 | gatesLeftInputs := r1cs.L[i]
195 | gatesRightInputs := r1cs.R[i]
196 | gatesOutputs := r1cs.O[i]
197 |
198 | leftKnowns, leftUnknowns := getKnownsAndUnknowns(gatesLeftInputs)
199 | rightKnowns, rightUnknowns := getKnownsAndUnknowns(gatesRightInputs)
200 |
201 | outKnowns, outUnknowns := getKnownsAndUnknowns(gatesOutputs)
202 |
203 | if len(leftUnknowns)+len(rightUnknowns)+len(outUnknowns) > 1 {
204 | return witness, errors.New(fmt.Sprintf("at gate %v:computing more then one unknown in Gate assignment is not possible", i))
205 | }
206 |
207 | // (a*x + b + c..) (d+e+..) = (F+g+..) we solve for x
208 | if len(leftUnknowns) == 1 {
209 | sumright := sum(rightKnowns)
210 | sumOut := sum(outKnowns)
211 | if sumright.Cmp(zero) == 0 && sumOut.Cmp(zero) == 0 {
212 | return witness, errors.New(fmt.Sprintf("at gate %v: the equation x*x = 0 is does not allow to determine x", i))
213 | }
214 | //result := utils.Field.ArithmeticField.Sub(sum(outKnowns), new(bn256.G1).ScalarBaseMult(sum(exponentKnowns)).X())
215 | result := utils.Field.ArithmeticField.Div(sumOut, sumright)
216 | result = utils.Field.ArithmeticField.Sub(result, sum(leftKnowns))
217 | result = utils.Field.ArithmeticField.Div(result, gatesLeftInputs[leftUnknowns[0]]) //divide by a
218 | setWitness(leftUnknowns[0], result)
219 | continue
220 | }
221 | // (a + b + c..) (d+e*x+..) = (F+g+..) we solve for x
222 | if len(rightUnknowns) == 1 {
223 | sumleft := sum(leftKnowns)
224 | sounOut := sum(outKnowns)
225 | if sumleft.Cmp(zero) == 0 && sounOut.Cmp(zero) == 0 {
226 | // 0 * a = 0
227 | // a cannot be determined
228 | return witness, errors.New(fmt.Sprintf("at gate %v: the equation 0 * x = 0 is does not allow to determine x", i))
229 | }
230 | //if sumleft.Cmp(zero) == 0 && sounOut.Cmp(zero) != 0 {
231 | // // 0 * a = 0
232 | // // a cannot be determined
233 | // return nil, errors.New(fmt.Sprintf("at gate %v:the summation of Lexer inputs cannot be 0 if the unknown is in R", i))
234 | //}
235 | result := utils.Field.ArithmeticField.Div(sounOut, sumleft)
236 | result = utils.Field.ArithmeticField.Sub(result, sum(rightKnowns))
237 | result = utils.Field.ArithmeticField.Div(result, gatesRightInputs[rightUnknowns[0]]) //divide by a
238 | setWitness(rightUnknowns[0], result)
239 | continue
240 | }
241 |
242 | // (a + b + c..) (d+e+..) = (F+x*g+..) we solve for x
243 | if len(outUnknowns) == 1 {
244 |
245 | result := utils.Field.ArithmeticField.Mul(sum(rightKnowns), sum(leftKnowns))
246 | result = utils.Field.ArithmeticField.Sub(result, sum(outKnowns))
247 | result = utils.Field.ArithmeticField.Div(result, gatesOutputs[outUnknowns[0]]) //divide by a
248 | setWitness(outUnknowns[0], result)
249 | continue
250 | }
251 | //we computed the unkown and now check if the ER1C is satisfied
252 | leftKnowns, leftUnknowns = getKnownsAndUnknowns(gatesLeftInputs)
253 | rightKnowns, rightUnknowns = getKnownsAndUnknowns(gatesRightInputs)
254 | outKnowns, outUnknowns = getKnownsAndUnknowns(gatesOutputs)
255 |
256 | if len(leftUnknowns)+len(rightUnknowns)+len(outUnknowns) != 0 {
257 | return witness, errors.New(fmt.Sprintf("at gate %v some unknowns remain", i))
258 |
259 | }
260 | //now check if the gate is satisfiable
261 | result := utils.Field.ArithmeticField.Mul(sum(rightKnowns), sum(leftKnowns))
262 | if result.Cmp(sum(outKnowns)) != 0 {
263 | return witness, errors.New(fmt.Sprintf("at equality gate %v there is unequality. %v != %v .We cannot process", i, result.String(), sum(outKnowns).String()))
264 | }
265 |
266 | }
267 |
268 | return
269 | }
270 |
--------------------------------------------------------------------------------
/Circuitcompiler/circuit_test.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | var CircuitCorrectnessTest = []string{
4 | `
5 | func main( a,b,c) {
6 | var a[] = {1,b,3,a}
7 | var k = a[a[0]*8/8]
8 | foo(a)
9 | var d = foo(a)
10 | return k * b *d
11 | }
12 | func foo(a){
13 | return a}
14 | `,
15 | }
16 |
17 | //func TestPrintTree(t *testing.T) {
18 | //
19 | // for _, test := range CircuitCorrectnessTest {
20 | //
21 | // program := Parse(test, true)
22 | //
23 | // fmt.Println("\n unreduced")
24 | // fmt.Println(test)
25 | //
26 | // container := program.Execute()
27 | // gates := container.orderedmGates
28 | // for _, g := range gates {
29 | // fmt.Printf("\n %v", g)
30 | // }
31 | //
32 | // //fmt.Println("\n generating R1CS")
33 | // //r1cs := program.GatesToR1CS(gates)
34 | // //fmt.Println(r1cs.Lexer)
35 | // //fmt.Println(r1cs.R)
36 | // //fmt.Println(r1cs.O)
37 | //
38 | // }
39 | //
40 | //}
41 |
--------------------------------------------------------------------------------
/Circuitcompiler/client.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package Circuitcompiler
6 |
7 | import (
8 | "bytes"
9 | "log"
10 | "net/http"
11 | "time"
12 |
13 | "github.com/gorilla/websocket"
14 | )
15 |
16 | const (
17 | // Time allowed to write a message to the peer.
18 | writeWait = 10 * time.Second
19 |
20 | // Time allowed to read the next pong message from the peer.
21 | pongWait = 60 * time.Second
22 |
23 | // Send pings to peer with this period. Must be less than pongWait.
24 | pingPeriod = (pongWait * 9) / 10
25 |
26 | // Maximum message size allowed from peer.
27 | maxMessageSize = 512
28 | )
29 |
30 | var (
31 | newline = []byte{'\n'}
32 | space = []byte{' '}
33 | )
34 |
35 | var upgrader = websocket.Upgrader{
36 | ReadBufferSize: 1024,
37 | WriteBufferSize: 1024,
38 | }
39 |
40 | // Client is a middleman between the websocket connection and the hub.
41 | type Client struct {
42 | hub *Hub
43 |
44 | // The websocket connection.
45 | conn *websocket.Conn
46 |
47 | // Buffered channel of outbound messages.
48 | send chan interface{}
49 | }
50 |
51 | // readPump pumps messages from the websocket connection to the hub.
52 | //
53 | // The application runs readPump in a per-connection goroutine. The application
54 | // ensures that there is at most one reader on a connection by executing all
55 | // reads from this goroutine.
56 | func (c *Client) readPump() {
57 | defer func() {
58 | c.hub.unregister <- c
59 | c.conn.Close()
60 | }()
61 | c.conn.SetReadLimit(maxMessageSize)
62 | c.conn.SetReadDeadline(time.Now().Add(pongWait))
63 | c.conn.SetPongHandler(func(string) error { c.conn.SetReadDeadline(time.Now().Add(pongWait)); return nil })
64 | for {
65 | _, message, err := c.conn.ReadMessage()
66 | if err != nil {
67 | if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
68 | log.Printf("error: %v", err)
69 | }
70 | break
71 | }
72 | message = bytes.TrimSpace(bytes.Replace(message, newline, space, -1))
73 | c.hub.broadcast <- message
74 | }
75 | }
76 |
77 | // writePump pumps messages from the hub to the websocket connection.
78 | //
79 | // A goroutine running writePump is started for each connection. The
80 | // application ensures that there is at most one writer to a connection by
81 | // executing all writes from this goroutine.
82 | func (c *Client) writePump() {
83 | ticker := time.NewTicker(pingPeriod)
84 | defer func() {
85 | ticker.Stop()
86 | c.conn.Close()
87 | }()
88 | for {
89 | select {
90 | case message, ok := <-c.send:
91 |
92 | c.conn.SetWriteDeadline(time.Now().Add(writeWait))
93 | if !ok {
94 | // The hub closed the channel.
95 | c.conn.WriteMessage(websocket.CloseMessage, []byte{})
96 | return
97 | }
98 |
99 | err := c.conn.WriteJSON(message) //NextWriter(websocket.TextMessage)
100 | if err != nil {
101 | return
102 | }
103 |
104 | case <-ticker.C:
105 | c.conn.SetWriteDeadline(time.Now().Add(writeWait))
106 | if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
107 | return
108 | }
109 | }
110 | }
111 | }
112 |
113 | // serveWs handles websocket requests from the peer.
114 | func serveWs(hub *Hub, w http.ResponseWriter, r *http.Request) {
115 | conn, err := upgrader.Upgrade(w, r, nil)
116 | if err != nil {
117 | log.Println(err)
118 | return
119 | }
120 | client := &Client{hub: hub, conn: conn, send: make(chan interface{}, 256)}
121 | client.hub.register <- client
122 |
123 | // Allow collection of memory referenced by the caller by doing all work in
124 | // new goroutines.
125 | go client.writePump()
126 | go client.readPump()
127 | }
128 |
--------------------------------------------------------------------------------
/Circuitcompiler/factorHandling.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "crypto/sha256"
5 | "fmt"
6 | "github.com/mottla/go-R1CS-Compiler/utils"
7 | "math/big"
8 | "sort"
9 | "strings"
10 | )
11 |
12 | var bigZero = big.NewInt(0)
13 | var bigOne = big.NewInt(1)
14 |
15 | func (f Tokens) Len() int {
16 | return len(f)
17 | }
18 |
19 | func (f Tokens) Swap(i, j int) {
20 | f[i], f[j] = f[j], f[i]
21 | }
22 |
23 | func (f Tokens) Less(i, j int) bool {
24 | if strings.Compare(f[i].String(), f[j].String()) < 0 {
25 | return false
26 | }
27 | return true
28 | }
29 | func (f Token) CopyAndSetMultiplicative(v *big.Int) (n Token) {
30 | n = f.copy()
31 | n.value = v
32 | return
33 | }
34 |
35 | func (f Tokens) containsArgument() bool {
36 | if len(f) == 0 {
37 | return false
38 | }
39 | //if len(f) != 1 {
40 | // panic("not expected")
41 | //}
42 | for _, v := range f {
43 | if v.isArgument {
44 | return true
45 | }
46 | }
47 | return false
48 | }
49 |
50 | func (f Token) Negate() (n Token) {
51 | return f.CopyAndSetMultiplicative(new(big.Int).Neg(f.value))
52 | }
53 | func (f Tokens) Negate() (n Tokens) {
54 | n = make(Tokens, len(f))
55 | for i, v := range f {
56 | n[i] = v.Negate()
57 | }
58 | return
59 | }
60 | func (t Token) toFactors() Tokens {
61 | if t.value == nil {
62 | t.value = bigOne
63 | }
64 | return Tokens{t}
65 | }
66 |
67 | func (f Tokens) clone() (res Tokens) {
68 | res = make(Tokens, len(f))
69 | for k, v := range f {
70 | res[k] = v.copy()
71 | }
72 | return
73 | }
74 |
75 | func extractGCD(f Tokens) (Tokens, *big.Int) {
76 |
77 | gcd := f[0].value
78 | for i := 1; i < len(f); i++ {
79 | gcd = new(big.Int).GCD(nil, nil, f[i].value, gcd)
80 | }
81 | for i := 0; i < len(f); i++ {
82 | f[i].value = new(big.Int).Div(f[i].value, gcd)
83 |
84 | }
85 | return f, gcd
86 |
87 | }
88 |
89 | func hashFactorsToBig(f Tokens) *big.Int {
90 | sha := sha256.New()
91 | for _, fac := range f {
92 | sha.Write([]byte(fac.String()))
93 | }
94 | return new(big.Int).SetBytes(sha.Sum(nil))
95 | }
96 |
97 | func (fac Tokens) factorSignature() string {
98 | h := hashFactorsToBig(fac)
99 | return h.String()[:16]
100 | }
101 |
102 | func extractConstant(leftFactors, rightFactors Tokens) (gcd *big.Int, extractedLeftFactors, extractedRightFactors Tokens) {
103 |
104 | mulL, facL := factorSignature(leftFactors)
105 | mulR, facR := factorSignature(rightFactors)
106 |
107 | res := utils.Field.ArithmeticField.Mul(mulL, mulR)
108 |
109 | return res, facL, facR
110 | }
111 |
112 | func factorSignature(facs Tokens) (gcd *big.Int, extractedRightFactors Tokens) {
113 | facs = facs.clone()
114 | facs, gcd = extractGCD(facs)
115 | sort.Sort(facs)
116 | return gcd, facs
117 | }
118 |
119 | //multiplies factor elements and returns the result
120 | //in case the Tokens do not hold any constants and all inputs are distinct, the extractedConstants will be the concatenation of left+right
121 | func mulFactors(leftFactors, rightFactors Tokens) (result Tokens) {
122 |
123 | if len(leftFactors) < len(rightFactors) {
124 | tmp := leftFactors
125 | leftFactors = rightFactors
126 | rightFactors = tmp
127 | }
128 |
129 | for i, left := range leftFactors {
130 |
131 | for _, right := range rightFactors {
132 |
133 | leftFactors[i] = leftFactors[i].CopyAndSetMultiplicative(mulType(right.value, left.value, right.Type))
134 |
135 | }
136 | }
137 | return leftFactors
138 | }
139 | func mulFactor(factors Tokens, multipl Token) (result Tokens) {
140 |
141 | for i, left := range factors {
142 |
143 | factors[i] = factors[i].CopyAndSetMultiplicative(mulType(multipl.value, left.value, left.Type))
144 |
145 | }
146 | return factors
147 | }
148 | func divideFactors(leftFactors Tokens, rightFactor Token) (result Tokens) {
149 |
150 | for i, left := range leftFactors {
151 |
152 | leftFactors[i] = leftFactors[i].CopyAndSetMultiplicative(divType(rightFactor.value, left.value, left.Type))
153 |
154 | }
155 | return leftFactors
156 | }
157 |
158 | //adds two Tokens to one iff they are both are constants or of the same variable
159 | func (in *Tokens) Add(a Token) {
160 |
161 | for i, v := range *in {
162 | if v.equalDescription(a) {
163 | (*in)[i].value = addType(v.value, a.value, a.Type)
164 | return
165 | }
166 | }
167 | *in = append(*in, a)
168 |
169 | return
170 |
171 | }
172 |
173 | //returns the reduced sum of two input factor arrays
174 | //if no reduction was done, it returns the concatenation of the input arrays
175 | func (this Tokens) AddFactors(with Tokens) Tokens {
176 |
177 | for _, facRight := range with {
178 | this.Add(facRight)
179 | }
180 |
181 | return this
182 | }
183 |
184 | func (from Tokens) primitiveReturnfunction() (gives *function) {
185 | if len(from) == 0 {
186 | return &function{}
187 | }
188 | if len(from) == 1 {
189 | return from[0].primitiveReturnfunction()
190 | }
191 |
192 | return combineFunctions(Token{
193 | Type: ArithmeticOperatorToken,
194 | Identifier: "+",
195 | }, from[0].primitiveReturnfunction(), from[1:].primitiveReturnfunction(), &function{})
196 |
197 | }
198 |
199 | func combineConstraints(operation string, lc, rc *Task) *Task {
200 | c := &Task{
201 | Description: Token{
202 | Type: ArithmeticOperatorToken,
203 | Identifier: operation,
204 | },
205 | Inputs: []*Task{lc, rc}}
206 | return c
207 | }
208 |
209 | func combineFunctions(operation Token, l, r, context *function) *function {
210 |
211 | rmp := NewCircuit("", context)
212 | if len(l.OutputTypes) != 1 {
213 | panic("")
214 | }
215 | if eq, err := l.hasEqualDescription(r); !eq {
216 | panic(err)
217 | }
218 | if operation.Type == BinaryComperatorToken || operation.Type == BooleanOperatorToken {
219 | rmp.OutputTypes = []returnTypes{{
220 | typ: Token{
221 | Type: BOOL,
222 | },
223 | }}
224 | } else {
225 | rmp.OutputTypes = l.OutputTypes
226 | }
227 |
228 | idL, idR := "l", "r"
229 | rmp.functions[idL] = l
230 | rmp.functions[idR] = r
231 | rmp.taskStack.add(&Task{
232 | Description: operation,
233 | Inputs: []*Task{
234 | {
235 | Description: Token{
236 | Type: FUNCTION_CALL,
237 | Identifier: idL,
238 | },
239 | }, {
240 | Description: Token{
241 | Type: FUNCTION_CALL,
242 | Identifier: idR,
243 | },
244 | }},
245 | })
246 | return rmp
247 | }
248 |
249 | func checkRangeValidity(in *big.Int, tokenType TokenType) bool {
250 | switch tokenType {
251 | case BOOL:
252 | if v := in.Uint64(); v > 1 {
253 | panic(fmt.Sprintf("boolean expected, got %v", v))
254 | }
255 | case U8:
256 | if v := in.Uint64(); v > 1<<8 {
257 | panic(fmt.Sprintf("Uint8 expected, got %v", v))
258 | }
259 |
260 | case U16:
261 | if v := in.Uint64(); v > 1<<16 {
262 | panic(fmt.Sprintf("Uint16 expected, got %v", v))
263 | }
264 |
265 | case U32:
266 | if v := in.Uint64(); v > 1<<32 {
267 | panic(fmt.Sprintf("uint32 expected, got %v", v))
268 | }
269 |
270 | case U64: //cannot be reached. since uint64 conversion would fail anyway
271 | if v := in.Uint64(); v > ^uint64(1) {
272 | panic(fmt.Sprintf("uint64 expected, got %v", v))
273 | }
274 | case FIELD:
275 |
276 | }
277 | return true
278 | }
279 | func addType(l, r *big.Int, tokenType TokenType) *big.Int {
280 | checkRangeValidity(l, tokenType)
281 | checkRangeValidity(r, tokenType)
282 | switch tokenType {
283 | case BOOL:
284 | return new(big.Int).Xor(l, r)
285 | case U8:
286 | ll, rr := l.Uint64(), r.Uint64()
287 |
288 | return new(big.Int).SetUint64(uint64(uint8(ll) + uint8(rr)))
289 |
290 | case U16:
291 | ll, rr := l.Uint64(), r.Uint64()
292 |
293 | return new(big.Int).SetUint64(uint64(uint16(ll) + uint16(rr)))
294 |
295 | case U32:
296 | ll, rr := l.Uint64(), r.Uint64()
297 |
298 | return new(big.Int).SetUint64(uint64(uint32(ll) + uint32(rr)))
299 |
300 | case U64: //cannot be reached. since uint64 conversion would fail anyway
301 | ll, rr := l.Uint64(), r.Uint64()
302 |
303 | return new(big.Int).SetUint64(ll + rr)
304 |
305 | case FIELD:
306 | return utils.Field.ArithmeticField.Add(l, r)
307 |
308 | case DecimalNumberToken:
309 |
310 | return utils.Field.ArithmeticField.Add(l, r)
311 | }
312 | panic("")
313 | }
314 |
315 | func mulType(l, r *big.Int, tokenType TokenType) *big.Int {
316 | checkRangeValidity(l, tokenType)
317 | checkRangeValidity(r, tokenType)
318 | switch tokenType {
319 | case BOOL:
320 | return utils.Field.ArithmeticField.Mul(l, r)
321 | case U8:
322 | ll, rr := l.Uint64(), r.Uint64()
323 |
324 | return new(big.Int).SetUint64(uint64(uint8(ll) * uint8(rr)))
325 |
326 | case U16:
327 | ll, rr := l.Uint64(), r.Uint64()
328 |
329 | return new(big.Int).SetUint64(uint64(uint16(ll) * uint16(rr)))
330 |
331 | case U32:
332 | ll, rr := l.Uint64(), r.Uint64()
333 |
334 | return new(big.Int).SetUint64(uint64(uint32(ll) * uint32(rr)))
335 |
336 | case U64: //cannot be reached. since uint64 conversion would fail anyway
337 | ll, rr := l.Uint64(), r.Uint64()
338 |
339 | return new(big.Int).SetUint64(ll * rr)
340 |
341 | case FIELD:
342 | return utils.Field.ArithmeticField.Mul(l, r)
343 | case DecimalNumberToken:
344 | return utils.Field.ArithmeticField.Mul(l, r)
345 | }
346 | panic("")
347 | }
348 | func divType(l, r *big.Int, tokenType TokenType) *big.Int {
349 | checkRangeValidity(l, tokenType)
350 | checkRangeValidity(r, tokenType)
351 | switch tokenType {
352 | case BOOL:
353 | return utils.Field.ArithmeticField.Div(l, r)
354 | case U8:
355 | ll, rr := l.Uint64(), r.Uint64()
356 |
357 | return new(big.Int).SetUint64(uint64(uint8(ll) / uint8(rr)))
358 |
359 | case U16:
360 | ll, rr := l.Uint64(), r.Uint64()
361 |
362 | return new(big.Int).SetUint64(uint64(uint16(ll) / uint16(rr)))
363 |
364 | case U32:
365 | ll, rr := l.Uint64(), r.Uint64()
366 |
367 | return new(big.Int).SetUint64(uint64(uint32(ll) / uint32(rr)))
368 |
369 | case U64: //cannot be reached. since uint64 conversion would fail anyway
370 | ll, rr := l.Uint64(), r.Uint64()
371 |
372 | return new(big.Int).SetUint64(ll / rr)
373 |
374 | case FIELD:
375 | return utils.Field.ArithmeticField.Div(l, r)
376 | case DecimalNumberToken:
377 |
378 | }
379 | panic("")
380 | }
381 |
--------------------------------------------------------------------------------
/Circuitcompiler/factorHandling_test.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "fmt"
5 | "math/big"
6 | "testing"
7 | )
8 |
9 | //Tokens are essential to identify, if a specific Gate has been computed already
10 | //eg. if we can extract a factor from a Gate that is independent of commutativity, multiplicativitz we will do much better, in finding and reusing old outputs do
11 | //minimize the multiplication Gate number
12 | // for example the Gate a*b == Gate b*a hence, we only need to compute one of both.
13 |
14 | func TestNewFactors(t *testing.T) {
15 | tks := Tokens{Token{
16 | Type: FIELD,
17 | Identifier: "",
18 | value: bigOne,
19 |
20 | isArgument: false,
21 |
22 | readInLine: 0,
23 | }}
24 | tks.Add(tks[0])
25 |
26 | tks.Add(Token{
27 | Type: FIELD,
28 | Identifier: "a",
29 | value: bigOne,
30 |
31 | isArgument: true,
32 | readInLine: 0,
33 | })
34 | fmt.Println(tks[0].String())
35 | tks.Add(Token{
36 | Type: FIELD,
37 | Identifier: "a",
38 | value: bigOne,
39 | isArgument: true,
40 | readInLine: 0,
41 | })
42 | fmt.Println(tks[0].String())
43 | tks.AddFactors(tks)
44 | fmt.Println(tks[0].String())
45 | fmt.Println(big.NewInt(0))
46 | }
47 |
48 | func TestToken_CopyAndSetMultiplicative(t *testing.T) {
49 | var a = 42
50 | var b = func() int { return a }
51 | a = 12
52 | fmt.Println(b())
53 |
54 | var c = []int{a, a}
55 | a = 3
56 | fmt.Println(c[1])
57 | }
58 |
--------------------------------------------------------------------------------
/Circuitcompiler/gate.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "fmt"
5 | "github.com/mottla/go-R1CS-Compiler/utils"
6 | "math/big"
7 | "sort"
8 | )
9 |
10 | type Gate struct {
11 | identifier string
12 | leftIns Tokens //leftIns and RightIns after addition gates have been reduced. only multiplication gates remain
13 | rightIns Tokens
14 | outIns Tokens
15 | //extractedConstants *big.Int
16 | noNewOutput bool
17 |
18 | computeYourselfe func(witness *[]*big.Int, set utils.FastBool, indexMap map[string]int) bool
19 | }
20 |
21 | func (g Gate) String() string {
22 | return fmt.Sprintf("Gate: %v with left %v right %v out %v", g.identifier, g.leftIns, g.rightIns, g.outIns)
23 | }
24 |
25 | func (gate *Gate) ID() (id string) {
26 | //TODO should we include the multiplicative in the hash?
27 | if gate.identifier == "" {
28 | return gate.setAndGetID()
29 | }
30 | return gate.identifier
31 | }
32 |
33 | func (gate *Gate) setAndGetID() (id string) {
34 | //TODO rethink
35 | //a*b = c
36 | //b*a = c
37 | //b= a^-1 * c
38 | //a*b *c^-1 = 1
39 | sort.Sort(gate.leftIns)
40 | sort.Sort(gate.rightIns)
41 | l := hashFactorsToBig(gate.leftIns)
42 | r := hashFactorsToBig(gate.rightIns)
43 | //we Add the hashes of the multiplication part. a cheap way to consider the commutativity in the id creation to avoid duplicates such as a*b and b*a
44 | lr := new(big.Int).Add(l, r)
45 | sort.Sort(gate.outIns)
46 | o := hashFactorsToBig(gate.outIns)
47 | lr = new(big.Int).Mul(lr, o)
48 | gate.identifier = lr.String()[:16]
49 | return gate.identifier
50 | }
51 |
52 | // id * id^-1 = 1
53 | func inverseGate(id Tokens) (g *Gate) {
54 | g = &Gate{
55 | leftIns: id,
56 | outIns: Token{
57 | Type: DecimalNumberToken,
58 | }.toFactors(),
59 | }
60 | g.rightIns = Token{Identifier: g.ID()}.toFactors()
61 | return
62 | }
63 |
64 | func multiplicationGate(left, right Tokens) (g *Gate) {
65 | g = &Gate{
66 | leftIns: left,
67 | rightIns: right,
68 | }
69 | g.outIns = Token{Identifier: g.ID()}.toFactors()
70 | return
71 | }
72 |
73 | //ensures that either left*right=0
74 | func zeroConstraintGate(left, right Tokens) (g *Gate) {
75 | g = &Gate{
76 | leftIns: left,
77 | rightIns: right,
78 | noNewOutput: true,
79 | }
80 | return
81 | }
82 |
83 | // a/b = c -> a = b*c
84 | func divisionGate(a, b Tokens) (g *Gate) {
85 | g = &Gate{
86 | leftIns: b,
87 | outIns: a,
88 | }
89 | g.rightIns = Token{Identifier: g.ID()}.toFactors()
90 | return
91 | }
92 |
93 | // (1-id)* id = 0
94 | func zeroOrOneGate(id string) (g *Gate) {
95 | one := Token{
96 | Type: ARGUMENT,
97 | value: bigOne,
98 | }
99 |
100 | g = &Gate{
101 | leftIns: Tokens{one,
102 | Token{
103 | Identifier: id,
104 | }.Negate(),
105 | },
106 | rightIns: Token{
107 | Identifier: id,
108 | }.toFactors(),
109 | identifier: id,
110 | }
111 | return
112 | }
113 |
114 | // a xor b = c as arithmetic circuit (asserting that a,b \in {0,1}
115 | // 2a*b = a + b - c
116 | func xorGate(a, b Token) (g *Gate) {
117 |
118 | var mGate = new(Gate)
119 | //some dangerous stuff is happening here.. check later dude
120 | mGate.leftIns = Tokens{a.CopyAndSetMultiplicative(new(big.Int).Mul(a.value, big.NewInt(2)))}
121 | mGate.rightIns = Tokens{b}
122 | mGate.outIns = Tokens{a, b}
123 |
124 | xor := Token{Identifier: mGate.ID(), value: bigOne}
125 |
126 | mGate.outIns = append(mGate.outIns, xor.Negate())
127 |
128 | return mGate
129 | }
130 |
131 | // a or b = c as arithmetic circuit (asserting that a,b \in {0,1}
132 | // a*b = a + b - c
133 | func orGate(a, b Token) (g *Gate) {
134 |
135 | var mGate = new(Gate)
136 |
137 | mGate.leftIns = Tokens{a}
138 | mGate.rightIns = Tokens{b}
139 | mGate.outIns = Tokens{a, b}
140 |
141 | xor := Token{Identifier: mGate.ID(), value: bigOne}
142 | mGate.outIns = append(mGate.outIns, xor.Negate())
143 |
144 | return mGate
145 | }
146 |
147 | //left * 1 = right
148 | func equalityGate(left, right Tokens) (g *Gate) {
149 | one := Token{
150 | Type: DecimalNumberToken,
151 | }.toFactors()
152 | g = &Gate{
153 | leftIns: left,
154 | rightIns: one,
155 | outIns: right,
156 | noNewOutput: true,
157 | }
158 | return
159 | }
160 |
161 | // (in1+in2+... )*1 = newOut
162 | func summationGate(in Tokens) (g *Gate) {
163 | one := Token{
164 | Type: DecimalNumberToken,
165 | }.toFactors()
166 | g = &Gate{
167 | leftIns: in,
168 | rightIns: one,
169 | }
170 | g.outIns = Token{Identifier: g.ID()}.toFactors()
171 | return
172 | }
173 |
174 | func (gate *Gate) minimizeR1CSDescriptiveComplexity() {
175 |
176 | //g^(e1+e2+..) + (r1+r2+..)*(l1+l2+..) = (c1+c2+..)
177 | //if g^e is 0, we can try if the constraint
178 | //l * 1/c = 1/r or
179 | //r * 1/c = 1/l or
180 | //r * 1/c = 1/l or
181 | //1/r*1/l=1/c
182 | //is the better represenant regarding bit complexity
183 |
184 | }
185 |
--------------------------------------------------------------------------------
/Circuitcompiler/gateContainer.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | type gateContainer struct {
4 | orderedmGates []*Gate
5 | computedFactors map[string]bool
6 | splittedElements map[string][]string
7 | }
8 |
9 | func newGateContainer() *gateContainer {
10 | return &gateContainer{
11 | orderedmGates: []*Gate{},
12 | computedFactors: make(map[string]bool),
13 | splittedElements: map[string][]string{}, //the array stores the indices of the zeroOrOne check gates
14 | }
15 | }
16 | func (g *gateContainer) OrderedGates() []*Gate {
17 | return g.orderedmGates
18 | }
19 |
20 | func (g *gateContainer) completeFunction(f Tokens) {
21 |
22 | //if len f is 1, we can simpl
23 | //todo single number call is outdated
24 | if f == nil || len(f) == 0 || !f.containsArgument() {
25 | return
26 | }
27 | //if the function {..return x*1} , we dont introduce a new gate, as knowledge proof of a multiplication with 1 is trivial and not necessary
28 | if len(f) == 1 && (f[0].value == nil || f[0].value.Cmp(bigOne) == 0) {
29 | return
30 | }
31 | //the function returned but had a extracted constant
32 | // example
33 | //main (x,y){
34 | //var x = y*y*3
35 | //return 4*x }
36 | // x will be set as y*y, and the 3 will be stored aside. each time we access x, we include the 3
37 | // if we now return, we get the factor 12. we expect the prover to perform the computation x*12
38 | // Note that some optimization still could be done here. if a gate is not used by others, we could multiply the factor into it
39 | // insteead of creating a new addition gate
40 | g.Add(summationGate(f))
41 |
42 | }
43 |
44 | func (g *gateContainer) contains(tok string) bool {
45 | _, ex := g.computedFactors[tok]
46 | return ex
47 | }
48 |
49 | func (g *gateContainer) Add(gate *Gate) (id Token) {
50 |
51 | if !gate.leftIns.containsArgument() && !gate.rightIns.containsArgument() && !gate.outIns.containsArgument() {
52 | //panic("gate where no input is an argument?")
53 | }
54 |
55 | if !g.contains(gate.ID()) {
56 | g.computedFactors[gate.ID()] = true
57 | g.orderedmGates = append(g.orderedmGates, gate)
58 | } else {
59 | //fmt.Println("saved reuse of "+gate.String())
60 | }
61 | var ty TokenType
62 | if gate.rightIns != nil {
63 | ty = gate.rightIns[0].Type
64 | }
65 | if gate.leftIns != nil {
66 | ty |= gate.leftIns[0].Type
67 | }
68 | if gate.outIns != nil {
69 | ty |= gate.outIns[0].Type
70 | }
71 | return Token{
72 | //todo note that thats bs
73 | Type: ty,
74 | Identifier: gate.ID(),
75 | isArgument: true,
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/Circuitcompiler/hub.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package Circuitcompiler
6 |
7 | import (
8 | "fmt"
9 | "time"
10 | )
11 |
12 | // Hub maintains the set of active clients and broadcasts messages to the
13 | // clients.
14 | type Hub struct {
15 | // Registered clients.
16 | clients map[*Client]bool
17 |
18 | // Inbound messages from the clients.
19 | broadcast chan interface{}
20 |
21 | // Register requests from the clients.
22 | register chan *Client
23 |
24 | // Unregister requests from clients.
25 | unregister chan *Client
26 | }
27 |
28 | func newHub() *Hub {
29 | return &Hub{
30 | broadcast: make(chan interface{}),
31 | register: make(chan *Client),
32 | unregister: make(chan *Client),
33 | clients: make(map[*Client]bool),
34 | }
35 | }
36 |
37 | func newAddNodeMsg() addNodeAndLinksMsg {
38 | return addNodeAndLinksMsg{Typeus: "addNode", Links: []int{}}
39 | }
40 |
41 | type addNodeAndLinksMsg struct {
42 | Typeus string `json:"type"`
43 | Id int `json:"id"`
44 | Links []int `json:"connections"`
45 | }
46 |
47 | func newAgentStateMsg() agentStateMsg {
48 | return agentStateMsg{Typeus: "stateChanged", ColorCha: []colorChange{}, AddLinks: []linkChange{}, RemLinks: []linkChange{}}
49 | }
50 |
51 | type agentStateMsg struct {
52 | Typeus string `json:"type"`
53 | ColorCha []colorChange `json:"colorChange"`
54 | AddLinks []linkChange `json:"linkAdd"`
55 | RemLinks []linkChange `json:"linkRem"`
56 | }
57 | type colorChange struct {
58 | Id string `json:"target"`
59 | Color string `json:"color"`
60 | Label string `json:"label"`
61 | }
62 | type linkChange struct {
63 | Target string `json:"target"`
64 | Source string `json:"source"`
65 | }
66 | type agentState struct {
67 | colC colorChange
68 | addL linkChange
69 | remL linkChange
70 | }
71 |
72 | func (h *Hub) run() {
73 |
74 | tkr := time.NewTicker(time.Second * 15)
75 |
76 | for {
77 | select {
78 | case client := <-h.register:
79 | fmt.Println("Client registered")
80 | h.clients[client] = true
81 | //go start(h)
82 | panic("asdf")
83 | case client := <-h.unregister:
84 | fmt.Println("Client tries to unregister")
85 | if _, ok := h.clients[client]; ok {
86 | delete(h.clients, client)
87 | close(client.send)
88 |
89 | fmt.Println("Client unregistered")
90 | }
91 | case message := <-h.broadcast:
92 |
93 | switch cast := message.(type) {
94 | case addNodeAndLinksMsg:
95 | for client := range h.clients {
96 | select {
97 | case client.send <- message:
98 | default:
99 | close(client.send)
100 | delete(h.clients, client)
101 | }
102 | }
103 | case agentStateMsg:
104 | for client := range h.clients {
105 | select {
106 | case client.send <- message:
107 | default:
108 | close(client.send)
109 | delete(h.clients, client)
110 | }
111 | }
112 | case []byte:
113 | fmt.Printf("byte messag type dude %v", string(cast))
114 |
115 | for client := range h.clients {
116 | select {
117 | case client.send <- string(cast):
118 | default:
119 | close(client.send)
120 | delete(h.clients, client)
121 | }
122 | }
123 | default:
124 | fmt.Printf("dunno this messag type dude ")
125 |
126 | }
127 | case c := <-tkr.C:
128 | for client := range h.clients {
129 | select {
130 | case client.send <- c.Local().UTC().String():
131 | //case client.send <- []byte(`{"num":6,"strs":["a","b"]}`):
132 | default:
133 | close(client.send)
134 | delete(h.clients, client)
135 | }
136 | }
137 | }
138 | }
139 | }
140 |
--------------------------------------------------------------------------------
/Circuitcompiler/lexer_test.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "fmt"
5 | "math/big"
6 | "testing"
7 | )
8 |
9 | func TestHexNumberState(t *testing.T) {
10 | v, b := new(big.Int).SetString("ABB", 16)
11 | if !b {
12 | panic("asdf")
13 | }
14 | println(v)
15 | v, b = new(big.Int).SetString("AbB", 16)
16 | if !b {
17 | panic("asdf")
18 | }
19 | println(v.String())
20 | }
21 | func Test_LexerError2(t *testing.T) {
22 | //code2 := `def main(a):
23 | // for(a = 3; a<3; a+=1){
24 | // var d = (c * (1+b) * k)
25 | // }
26 | // return d `
27 | //
28 | code := `
29 | var a u64
30 |
31 | `
32 |
33 | fmt.Println(code)
34 | l := New(code, ProbablyWhitespaceState)
35 | l.Start()
36 | tok, done := l.NextToken()
37 | for !done {
38 | fmt.Printf("%v , %q \n", tok.Type, tok.Identifier)
39 | tok, done = l.NextToken()
40 | }
41 |
42 | fmt.Println("done")
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/Circuitcompiler/parser_test.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 | )
7 |
8 | func TestBuild(t *testing.T) {
9 | c := []string{}
10 | ArrayStringBuild([]int64{2, 3, 4}, "", &c)
11 | fmt.Println(c)
12 | }
13 |
14 | func TestParser_PrepareFunctionHeader(t *testing.T) {
15 | code := `
16 | func test(a field, b func(a field))(field,field) {
17 |
18 | }
19 | `
20 | parser := NewParser(code, false)
21 | toks := parser.stackAllTokens()
22 | functionInput, rest := splitAtFirstHighestStringType(toks[3:], "{")
23 | fmt.Println(rest)
24 | fk := NewCircuit("", nil)
25 | parser.PrepareFunctionSignature(fk, functionInput)
26 | fmt.Println(fk)
27 | }
28 |
29 | func TestArray(t *testing.T) {
30 | code := `a[4][3]`
31 | parser := NewParser(code, false)
32 | toks := parser.stackAllTokens()
33 | toks = toks[:len(toks)-1]
34 | ct := Task{}
35 | parser.parseExpression(toks, NewCircuit("", &function{}), &Task{})
36 | fmt.Println(ct)
37 | }
38 | func TestNewParse(t *testing.T) {
39 | code := `
40 | func main(x bool[4][5],y bool)(field) {
41 | bool[4][3] in = [[4,1,1],[1,1,1],[1,1,1],[1,1,1]]
42 | return x[1][1]*in[0][0]
43 | }
44 | `
45 | p := Parse(code)
46 | container := p.Execute()
47 |
48 | gates := container.OrderedGates()
49 | fmt.Println("\n generating R1CS")
50 | r1cs := p.GatesToR1CS(gates)
51 | fmt.Printf("number of gates %v, witness length %v \n ", r1cs.NumberOfGates, r1cs.WitnessLength)
52 | //
53 | fmt.Println(r1cs.L)
54 | fmt.Println(r1cs.R)
55 | fmt.Println(r1cs.O)
56 | }
57 |
58 | func TestNewParse2(t *testing.T) {
59 | code := `
60 | func mul(x bool,y bool)(bool){
61 | return x*y
62 | }
63 |
64 | func mul2(x bool,y bool)(bool,bool){
65 | return x*x,y*y
66 | }
67 |
68 | func mul3(x bool,y func(x bool,y bool)(bool) )(field){
69 | return y(x,x)
70 | }
71 |
72 | func main(x bool,y field)(field) {
73 | #func m5(x bool)(bool){return mul(5,x)}
74 | x,x = mul2(x,x)
75 | return mul3(x,mul)
76 | }
77 |
78 | `
79 | p := Parse(code)
80 | container := p.Execute()
81 |
82 | gates := container.OrderedGates()
83 | fmt.Println("\n generating R1CS")
84 | r1cs := p.GatesToR1CS(gates)
85 | fmt.Printf("number of gates %v, witness length %v \n ", r1cs.NumberOfGates, r1cs.WitnessLength)
86 | //
87 | fmt.Println(r1cs.L)
88 | fmt.Println(r1cs.R)
89 | fmt.Println(r1cs.O)
90 | }
91 |
92 | //only to see the difference between the split funcitons
93 | func TestParser_SplitAt(t *testing.T) {
94 | toks := []Token{
95 | {
96 | Identifier: "a",
97 | },
98 | {
99 | Identifier: "b",
100 | },
101 | {
102 | Identifier: "c",
103 | },
104 | {
105 | Identifier: "a",
106 | },
107 | {
108 | Identifier: "e",
109 | },
110 | {
111 | Identifier: ")",
112 | },
113 | {
114 | Identifier: "a",
115 | },
116 | }
117 |
118 | fmt.Println(splitTokensAtFirstString(toks, ")"))
119 |
120 | fmt.Println(splitAt(toks, ")"))
121 |
122 | fmt.Println(splitAtClosingBrackets(toks))
123 |
124 | }
125 |
126 | //only to see the difference between the split funcitons
127 | func TestParser_StripOfBrackets(t *testing.T) {
128 | toks := []Token{
129 | {
130 | Identifier: "(",
131 | },
132 | {
133 | Identifier: "b",
134 | },
135 | {
136 | Identifier: "c",
137 | },
138 | {
139 | Identifier: "a",
140 | },
141 | {
142 | Identifier: "e",
143 | },
144 | {
145 | Identifier: "g",
146 | },
147 | {
148 | Identifier: ")",
149 | },
150 | }
151 | fmt.Println(toks)
152 | fmt.Println(stripOfBrackets(toks))
153 | }
154 |
--------------------------------------------------------------------------------
/Circuitcompiler/rune_stack.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | type runeNode struct {
4 | r rune
5 | next *runeNode
6 | }
7 |
8 | type runeStack struct {
9 | start *runeNode
10 | linebreaksOnStack int
11 | }
12 |
13 | func newRuneStack() runeStack {
14 | return runeStack{}
15 | }
16 |
17 | func (s *runeStack) push(r rune) {
18 | node := &runeNode{r: r}
19 | if s.start == nil {
20 | s.start = node
21 | } else {
22 | node.next = s.start
23 | s.start = node
24 | }
25 |
26 | }
27 |
28 | func (s *runeStack) pop() rune {
29 | if s.start == nil {
30 | return EOFRune
31 | } else {
32 | n := s.start
33 | s.start = n.next
34 | return n.r
35 | }
36 | }
37 |
38 | func (s *runeStack) clear() {
39 | s.start = nil
40 | }
41 |
--------------------------------------------------------------------------------
/Circuitcompiler/server.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "log"
5 | "net/http"
6 | )
7 |
8 | func StartServer(addr *string) *Hub {
9 | hub := newHub()
10 | go hub.run()
11 |
12 | http.Handle("/", http.FileServer(http.Dir("./Circuitcompiler/web_vivagraph")))
13 |
14 | http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
15 | serveWs(hub, w, r)
16 | })
17 | go func() {
18 | err := http.ListenAndServe(*addr, nil)
19 | if err != nil {
20 |
21 | log.Fatal("ListenAndServe: ", err)
22 | }
23 | }()
24 |
25 | return hub
26 | }
27 |
--------------------------------------------------------------------------------
/Circuitcompiler/visualizer.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | //func start(hub *Hub) {
4 | //
5 | // code := testPrograms.TestPrograms[3]
6 | //
7 | // program := Parse(code.Code, true)
8 | // container := program.Execute()
9 | // gates := container.OrderedGates()
10 | // res := newAgentStateMsg()
11 | //
12 | // for _, g := range gates {
13 | //
14 | // //if g.gateType == additionGate {
15 | // // res.ColorCha = append(res.ColorCha, colorChange{
16 | // // Id: g.identifier,
17 | // // Color: "#FFD6E7",
18 | // // Label: "+",
19 | // // })
20 | // //}
21 | // //if g.gateType == multiplicationGate {
22 | // res.ColorCha = append(res.ColorCha, colorChange{
23 | // Id: g.identifier,
24 | // Color: "#AAD8D8",
25 | // Label: "x",
26 | // })
27 | // //}
28 | //
29 | // for _, l := range g.leftIns {
30 | //
31 | // if l.Typ.Type == DecimalNumberToken {
32 | // res.ColorCha = append(res.ColorCha, colorChange{
33 | // Id: g.identifier,
34 | // Color: "#F6C3B7",
35 | // //Label: l.String(),
36 | // })
37 | // }
38 | //
39 | // res.AddLinks = append(res.AddLinks, linkChange{
40 | // Target: g.identifier,
41 | // Source: l.Typ.Identifier,
42 | // })
43 | // }
44 | // for _, l := range g.rightIns {
45 | // if l.Typ.Type == DecimalNumberToken {
46 | // res.ColorCha = append(res.ColorCha, colorChange{
47 | // Id: g.identifier,
48 | // Color: "#BDEFDB",
49 | // //Label: l.String(),
50 | // })
51 | // }
52 | //
53 | // res.AddLinks = append(res.AddLinks, linkChange{
54 | // Target: g.identifier,
55 | // Source: l.Typ.Identifier,
56 | // })
57 | // }
58 | // for _, l := range g.outIns {
59 | //
60 | // res.AddLinks = append(res.AddLinks, linkChange{
61 | // Target: g.identifier,
62 | // Source: l.Typ.Identifier,
63 | // })
64 | // }
65 | //
66 | // }
67 | // hub.broadcast <- res
68 | //
69 | // return
70 | //}
71 |
--------------------------------------------------------------------------------
/Circuitcompiler/visualizer_test.go:
--------------------------------------------------------------------------------
1 | package Circuitcompiler
2 |
3 | import (
4 | "flag"
5 | "fmt"
6 | "testing"
7 | )
8 |
9 | var addr = flag.String("addr", "127.0.0.1:8081", "http service address")
10 |
11 | func Test(t *testing.T) {
12 | StartServer(addr)
13 | fmt.Println("Server is running")
14 | <-make(chan bool)
15 |
16 | }
17 |
--------------------------------------------------------------------------------
/Circuitcompiler/web_g6/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mottla/go-R1CS-Compiler/031a8c5ac1b75340dc9acd45c86b2b7166091d8a/Circuitcompiler/web_g6/favicon.ico
--------------------------------------------------------------------------------
/Circuitcompiler/web_g6/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | VivaGraphs webgl dynamic graph test page
6 |
7 |
8 |
9 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
104 |
105 |
117 |
118 |
119 |
120 |
121 |
Use Shift + Mouse to draw rectangle and select nodes
122 |
123 |
124 |
125 |
126 |
127 |