[FEAT] Full refactor of gnark circuits which reuse code now,

Removed SecretData from required parameters because it's computed inside circuits

gnark/circuits/aesV2_oprf/aes.go

@@ -33,7 +33,5 @@ func (c *AESTOPRFCircuit) Define(api frontend.API) error {
 		}
 	}
 
-	c.TOPRF.SecretData = toprf.ExtractSecretElements(api, outBits, c.Bitmask[:], c.Len)
-
-	return toprf.VerifyTOPRF(api, &c.TOPRF)
+	return toprf.VerifyTOPRF(api, &c.TOPRF, toprf.ExtractSecretElements(api, outBits, c.Bitmask[:], c.Len))
 }

gnark/circuits/aesV2_oprf/aes128_test.go

@@ -25,8 +25,7 @@ func TestAES128(t *testing.T) {
 
 	secretStr := "00000000001111111111000000000011000000000011111111110000000000" // max 62 bytes
 	secretBytes := []byte(secretStr)
-	d, err := toprf.PrepareTestData(secretStr, "reclaim")
-	assert.NoError(err)
+	d, _ := toprf.PrepareTestData(secretStr, "reclaim")
 
 	pos := 18
 	Counter := 12345
@@ -79,7 +78,6 @@ func createWitness(d *toprf.Params, bKey []uint8, bNonce []uint8, counter int, c
 		Out: [aes_v2.BLOCKS * 16]frontend.Variable{},
 		Len: l,
 		TOPRF: toprf.Params{
-			SecretData:      [2]frontend.Variable{0, 0}, // will be rewritten inside
 			Mask:            d.Mask,
 			DomainSeparator: d.DomainSeparator,
 			Responses:       d.Responses,

gnark/circuits/aesV2_oprf/aes256_test.go

@@ -25,8 +25,7 @@ func TestAES256(t *testing.T) {
 
 	secretStr := "00000000001111111111000000000011" // max 62 bytes
 	secretBytes := []byte(secretStr)
-	d, err := toprf.PrepareTestData(secretStr, "reclaim")
-	assert.NoError(err)
+	d, _ := toprf.PrepareTestData(secretStr, "reclaim")
 
 	pos := 30
 	Counter := 12345
@@ -68,7 +67,6 @@ func createWitness256(d *toprf.Params, bKey []uint8, bNonce []uint8, counter int
 		Out: [aes_v2.BLOCKS * 16]frontend.Variable{},
 		Len: l,
 		TOPRF: toprf.Params{
-			SecretData:      [2]frontend.Variable{0, 0}, // will be rewritten inside
 			Mask:            d.Mask,
 			DomainSeparator: d.DomainSeparator,
 			Responses:       d.Responses,

gnark/circuits/chachaV3_oprf/circuit.go → gnark/circuits/chachaV3_oprf/chacha.go

@@ -35,7 +35,5 @@ func (c *ChachaTOPRFCircuit) Define(api frontend.API) error {
 		}
 	}
 
-	c.TOPRF.SecretData = toprf.ExtractSecretElements(api, outBits, c.Bitmask[:], c.Len)
-
-	return toprf.VerifyTOPRF(api, &c.TOPRF)
+	return toprf.VerifyTOPRF(api, &c.TOPRF, toprf.ExtractSecretElements(api, outBits, c.Bitmask[:], c.Len))
 }

gnark/circuits/chachaV3_oprf/chacha_test.go

@@ -41,8 +41,7 @@ func TestCipher(t *testing.T) {
 	cipher.SetCounter(uint32(counter))
 	cipher.XORKeyStream(ciphertext, plaintext)
 
-	d, err := toprf.PrepareTestData(secretStr, "reclaim")
-	assert.NoError(err)
+	d, _ := toprf.PrepareTestData(secretStr, "reclaim")
 
 	witness := createWitness(d, bKey, bNonce, counter, ciphertext, plaintext, pos, len(secretBytes))
 
@@ -74,7 +73,6 @@ func createWitness(d *toprf.Params, bKey []uint8, bNonce []uint8, counter int, c
 	witness := ChachaTOPRFCircuit{
 		Len: len,
 		TOPRF: toprf.Params{
-			SecretData:      [2]frontend.Variable{0, 0}, // will be rewritten inside
 			Mask:            d.Mask,
 			DomainSeparator: d.DomainSeparator,
 			Responses:       d.Responses,

gnark/circuits/toprf/testdata.go

@@ -25,10 +25,10 @@ type TestData struct {
 	Proof      *Proof
 }
 
-func PrepareTestData(secretData string, domainSeparator string) (*Params, error) {
+func PrepareTestData(secretData string, domainSeparator string) (*Params, [2]frontend.Variable) {
 	req, err := utils.OPRFGenerateRequest([]byte(secretData), domainSeparator)
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	// server secret
@@ -42,7 +42,7 @@ func PrepareTestData(secretData string, domainSeparator string) (*Params, error)
 
 	shares, err := utils.TOPRFCreateShares(nodes, threshold, sk)
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	idxs := utils.PickRandomIndexes(nodes, threshold)
@@ -60,7 +60,7 @@ func PrepareTestData(secretData string, domainSeparator string) (*Params, error)
 		var resp *utils.OPRFResponse
 		resp, err = utils.OPRFEvaluate(shares[idx].PrivateKey, req.MaskedData)
 		if err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		resps[i] = utils.OutPointToInPoint(resp.EvaluatedPoint)
@@ -74,16 +74,15 @@ func PrepareTestData(secretData string, domainSeparator string) (*Params, error)
 	// without TOPRF
 	resp, err := utils.OPRFEvaluate(sk, req.MaskedData)
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	out, err := utils.OPRFFinalize(serverPublic, req, resp)
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	data := &Params{
-		SecretData:      [2]frontend.Variable{req.SecretElements[0], req.SecretElements[1]},
 		DomainSeparator: new(big.Int).SetBytes([]byte(domainSeparator)),
 		Output:          out,
 		Mask:            req.Mask,
@@ -95,5 +94,5 @@ func PrepareTestData(secretData string, domainSeparator string) (*Params, error)
 	copy(data.C[:], cs)
 	copy(data.R[:], rs)
 
-	return data, nil
+	return data, [2]frontend.Variable{req.SecretElements[0], req.SecretElements[1]}
 }

gnark/circuits/toprf/toprf.go

@@ -16,7 +16,6 @@ const Threshold = 1
 const BytesPerElement = 31
 
 type Params struct {
-	SecretData      [2]frontend.Variable
 	DomainSeparator frontend.Variable `gnark:",public"`
 	Mask            frontend.Variable
 	Responses       [Threshold]twistededwards.Point `gnark:",public"` // responses per each node
@@ -29,10 +28,11 @@ type Params struct {
 
 type TOPRF struct {
 	*Params
+	SecretData [2]frontend.Variable
 }
 
 func (n *TOPRF) Define(api frontend.API) error {
-	return VerifyTOPRF(api, n.Params)
+	return VerifyTOPRF(api, n.Params, n.SecretData)
 }
 
 func ExtractSecretElements(api frontend.API, bits, bitmask []frontend.Variable, l frontend.Variable) [2]frontend.Variable {
@@ -71,7 +71,7 @@ func ExtractSecretElements(api frontend.API, bits, bitmask []frontend.Variable,
 	return [2]frontend.Variable{res1, res2}
 }
 
-func VerifyTOPRF(api frontend.API, p *Params) error {
+func VerifyTOPRF(api frontend.API, p *Params, secretData [2]frontend.Variable) error {
 	curve, err := twistededwards.NewEdCurve(api, tbn.BN254)
 	if err != nil {
 		return err
@@ -85,7 +85,7 @@ func VerifyTOPRF(api frontend.API, p *Params) error {
 	maskBits := bits.ToBinary(api, p.Mask, bits.WithNbDigits(api.Compiler().Field().BitLen()))
 	mask := field.FromBits(maskBits...)
 
-	dataPoint, err := hashToPoint(api, curve, p.SecretData, p.DomainSeparator)
+	dataPoint, err := hashToPoint(api, curve, secretData, p.DomainSeparator)
 	if err != nil {
 		return err
 	}
@@ -115,8 +115,8 @@ func VerifyTOPRF(api frontend.API, p *Params) error {
 
 	hash.Write(unMasked.X)
 	hash.Write(unMasked.Y)
-	hash.Write(p.SecretData[0])
-	hash.Write(p.SecretData[1])
+	hash.Write(secretData[0])
+	hash.Write(secretData[1])
 	out := hash.Sum()
 
 	api.AssertIsEqual(p.Output, out)

gnark/circuits/toprf/toprf_test.go

@@ -14,11 +14,11 @@ import (
 
 func TestTOPRF(t *testing.T) {
 	assert := test.NewAssert(t)
-	testData, err := PrepareTestData("randomiiiiiiiiiiiiiizerrandomiiiiiiiiiiiiiizerrandomiiiiiiiiir", "")
-	assert.NoError(err)
+	testData, secretData := PrepareTestData("randomiiiiiiiiiiiiiizerrandomiiiiiiiiiiiiiizerrandomiiiiiiiiir", "")
 
 	wtns := TOPRF{
-		Params: testData,
+		Params:     testData,
+		SecretData: secretData,
 	}
 
 	assert.CheckCircuit(&wtns, test.WithCurves(ecc.BN254), test.WithValidAssignment(&wtns))

gnark/libraries/core_test.go

@@ -620,7 +620,7 @@ func TestFullAES256OPRF(t *testing.T) {
 func Benchmark_ProveAES128(b *testing.B) {
 	prover.InitAlgorithm(prover.AES_128, aes128Key, aes128r1cs)
 	b.ResetTimer()
-	params := `{"cipher":"aes-128-ctr","key":[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],"nonce":[3,3,3,3,3,3,3,3,3,3,3,3],"counter":2,"input":[183,4,206,60,254,21,117,9,150,227,246,245,71,101,56,67,79,93,44,163,22,89,128,55,214,254,228,214,89,253,176,112,138,115,93,140,194,222,104,252,49,144,91,252,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}`
+	params := `{"cipher":"aes-128-ctr","key":"Ilqk8vMs/lrdrt9bEpM3qQ==","nonce":"/T8j2un1mcMh0Lt4","counter":298071680,"input":"mBiZrxJnp1ALlddPWenBt12YsVzSMFudhjbMC9rZtx//D0LMi5R8+/bzkKZgTaoxy3N0Gdgf5//U7kObAKBNE3votSHtiNhZUUZsoUvD5fw="}`
 	for i := 0; i < b.N; i++ {
 		prover.Prove([]byte(params))
 	}
@@ -630,7 +630,7 @@ func Benchmark_ProveAES128(b *testing.B) {
 func Benchmark_ProveAES256(b *testing.B) {
 	prover.InitAlgorithm(prover.AES_256, aes256Key, aes256r1cs)
 	b.ResetTimer()
-	params := `{"cipher":"aes-256-ctr","key":[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],"nonce":[3,3,3,3,3,3,3,3,3,3,3,3],"counter":10,"input":[189,250,225,242,6,46,173,203,7,166,62,139,67,150,1,155,64,122,211,198,184,203,124,194,99,34,127,29,236,17,232,214,154,146,78,217,254,224,208,196,55,200,23,93,90,175,240,31,31,225,26,15,219,156,123,21,103,98,205,87,197,22,245,158]}`
+	params := `{"cipher":"aes-256-ctr","key":"D90Byc5KBESfgf52T5T+VbKIR56UCldsfD/k3QRq1FU=","nonce":"xaPdohzb+eNGkzhl","counter":2841725616,"input":"l4nng90p9WsrHCVYqIB0UoBPEOnZxigJ7qSGTRMU5nEgrXO7CpqmQov0p4eZ4bKJI3SvpgQ2jxqu+FJDjzINA9aI72YcXf4AYGtI8+sl/Ig="}`
 	for i := 0; i < b.N; i++ {
 		prover.Prove([]byte(params))
 	}
@@ -640,7 +640,37 @@ func Benchmark_ProveAES256(b *testing.B) {
 func Benchmark_ProveChacha(b *testing.B) {
 	prover.InitAlgorithm(prover.CHACHA20, chachaKey, chachaR1CS)
 	b.ResetTimer()
-	params := `{"cipher":"chacha20","key":[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],"nonce":[3,3,3,3,3,3,3,3,3,3,3,3],"counter":3,"input":[163,247,229,146,174,218,21,7,167,245,27,53,129,45,252,80,162,99,213,166,210,223,98,94,86,59,2,228,156,8,191,48,208,231,72,63,91,19,255,7,149,50,34,78,232,251,195,26,177,137,155,24,228,83,211,109,151,147,168,53,94,176,222,233]}`
+	params := `{"cipher":"chacha20","key":"DAKfm7e+mFt0cCGacGmnDm5fVZ7UWyv7O53J27yePbs=","nonce":"I3zQZE9P8e7lXG6a","counter":1757507854,"input":"ShLAJduinXP+uOyxYoFNcUzR4c59QbcFed8YlIBPD3yRJhrVwB06tAIfP0TC2AUMztD7q60vAsK/at+WI9U0+fsgNDLhqI912HvyE1oUFm5XHpTC5VtVg1p0N4/ZjXaa7Wd9sWc2ty5eP8lEjGVzyRX6Goi+vygtkwh/1qJRc/I="}`
+	for i := 0; i < b.N; i++ {
+		prover.Prove([]byte(params))
+	}
+	b.ReportAllocs()
+}
+
+func Benchmark_ProveAES128OPRF(b *testing.B) {
+	prover.InitAlgorithm(prover.AES_128_OPRF, aes128OprfKey, aes128Oprfr1cs)
+	b.ResetTimer()
+	params := `{"cipher":"aes-128-ctr-toprf","key":"ZAWxNb2AdgO39yzI14XsZA==","nonce":"LBsTWdRfQ2J7unF2","counter":2260824246,"input":"UTnKUAkCBrEYiC2tPMnGliYTdcbVFXrFhFRH3m3N5zl5XUhfljrNTdquVVeL2PleSc3w5m2ZI6kVePRaC/OWC8tQjwk4n7WpB8D4IpqQHSU=","toprf":{"pos":12,"len":14,"mask":"A1BXFdPv8/KMIWHKi5ayD+Ngj2x8CEqPIXaS94kBNxg=","domainSeparator":"cmVjbGFpbQ==","output":"IShCRuW+UON6xy/va104/4qxauCxbF/boK4SjbExTMM=","responses":[{"index":0,"publicKeyShare":"n/wRU9Jw6bMF/f+IwhF3SJmBQ9IevOCcNu6HOGV7NQg=","evaluated":"KhzfVQOJZfu7tacCPV82IzgmZsl9m4g931kTPvmg16Q=","c":"LeUBWWxMeLTK201i0QcyFEguuBwHOIkgWyebJHb4KuY=","r":"ATMhm3RUePybiYqj+dGM8OssXZPpkGXVeiNdoxKHhLY="}]}}`
+	for i := 0; i < b.N; i++ {
+		prover.Prove([]byte(params))
+	}
+	b.ReportAllocs()
+}
+
+func Benchmark_ProveAES256OPRF(b *testing.B) {
+	prover.InitAlgorithm(prover.AES_256_OPRF, aes256OprfKey, aes256Oprfr1cs)
+	b.ResetTimer()
+	params := `{"cipher":"aes-256-ctr-toprf","key":"4IpME0BPXBIlVL7TdbRPktZVqqxQ+cUZaZN1ZQH+HXI=","nonce":"mMrCGydl9N4uwKxN","counter":4148389242,"input":"6DOHCarJBb8OdKf3cWakFKgn9BV/eVPQPaBlNwSRHA7GoGs6ijTygZwuBsYGbIw35q3U+OHyhD5M181U7Mx25uaFlZzbMr6xPp0LYk4YWuM=","toprf":{"pos":12,"len":14,"mask":"jiWalfzXdcn7geSk8UmfvaIzHiBo9AlhIm4mJT6qhg==","domainSeparator":"cmVjbGFpbQ==","output":"L0io3LqaeEdNSnZBJzAM46zlxZH30wxNf38cEvYWhhw=","responses":[{"index":1,"publicKeyShare":"y1wKCxI/i+OF8Nfjc9DyXmz67DtfWxk9fWnlFqTnlxs=","evaluated":"UApaFttzi54ShGcrXcpMKapa4emphZbdI3MNsKBjMpw=","c":"GWQKZ7Q54L2TjDvLtywRuD6AXt+8uvrQ+jGHuKIIpY4=","r":"A4RxrU5gOa0LMgLKhHVp4SfknOvYIIOLcWVPBwJ7zj4="}]}}`
+	for i := 0; i < b.N; i++ {
+		prover.Prove([]byte(params))
+	}
+	b.ReportAllocs()
+}
+
+func Benchmark_ProveChachaOPRF(b *testing.B) {
+	prover.InitAlgorithm(prover.CHACHA20_OPRF, chachaOprfKey, chachaOprfr1cs)
+	b.ResetTimer()
+	params := `{"cipher":"chacha20-toprf","key":"Ka3Qs7LgwGaRQwIXYSQKYF1bpKX7BntH1+gbgiMHyYM=","nonce":"yLApW3mIK0mM3uE9","counter":4168221410,"input":"zDdyXezLpcexVGYoZoyuFIDjpXZCV+YSVbDd5SfRHge7HEril7C0gnqR7dPbMwj/2t9g5mU4x/2bvl+grkeyUT33HCyRvebvAEfDkGENP5aO2MC71P7ynYGIAV7/4QbkflQRA9pdKOHfqCSEzd4GqNaaIKzF1/A6AHXuaeOOg5U=","toprf":{"pos":59,"len":14,"mask":"BIvVtZdOIiZSDWb1/sLKqoEXhx4mc4Kmv580KPbll3Q=","domainSeparator":"cmVjbGFpbQ==","output":"CUcueErhemKezndgP7vjGImvG8ua9104RJe8QhNcuOc=","responses":[{"index":0,"publicKeyShare":"0W07hZxwL42VhLULWKIkYDAuukzGBuCafqZVPTWPrq8=","evaluated":"JxObYdh6IlUR4+GV6Z1oBcWr5wEnWzuWUHX07gGQ+So=","c":"FUBwJawrBPQe3OJs6zLj4vpz2SEG4AU1Q6ucXIZrCyM=","r":"A8NG/ewWaCAef6Mowvq4XTgVtRRcRvaD6edkrsirUOw="}]}}`
 	for i := 0; i < b.N; i++ {
 		prover.Prove([]byte(params))
 	}

gnark/libraries/prover/impl/library.go

@@ -35,33 +35,33 @@ var algorithmNames = map[uint8]string{
 
 var provers = map[string]*ProverParams{
 	"chacha20": {
-		KeyHash:     "6c84adfffae0183ad7d333e324079a7787e56caa79b1d3c8894dd9cdbc942838",
+		KeyHash:     "4bfc68e4cf1fc95a8bcd83b07ca980c227c3a333c1c70d1ef5ab7982ea2cc30b",
 		CircuitHash: "4382aa593cfe8f3b3dcd35cff62a27d8ca2b415dae64bdeca2a561a707fabab0",
 		Prover:      &ChaChaProver{},
 	},
 	"aes-128-ctr": {
-		KeyHash:     "9cb4e54cc2a4b090ac58010b6b5c11647ecb805900f2ab5acea73b33adc68354",
+		KeyHash:     "618fe3b1781170993eb8645925335ece4bd22277c26b372bf9713dcbeecf84f1",
 		CircuitHash: "b1ee478f009fe81946e6e2768ef0b6d62ab266525f186baaa4e8dec61b6e3ea6",
 		Prover:      &AESProver{},
 	},
 	"aes-256-ctr": {
-		KeyHash:     "2fe18d977c42fc1696e4c4b39a26a5513918c3970db6d5bc23cf90e54348fed6",
+		KeyHash:     "522e51d29d81605e0211485ee5630a52b85cb0f88e476e85b74ab4db7b482c27",
 		CircuitHash: "e62f8e74b17cad4012513cf23971ddf58faa63a4a87676047bccd255021dee13",
 		Prover:      &AESProver{},
 	},
 	"chacha20-toprf": {
-		KeyHash:     "385b2bfe8c4eb2837d71a26e1610b48e1eb09ea25f1b77c42176f6d5ed981076",
-		CircuitHash: "a89a1dd02fa019efe7c0964e2a4e594d7843f69293a67b2bfd111da5bf998c92",
+		KeyHash:     "153dd306e5f90d1c239cc63efa1a98e19e5d6fac6fb22dc1b18c4bffd23be5c2",
+		CircuitHash: "9107e9b1fbb174cff7a662e02c8f3f04dd6c8ba305303a94f5d0513dda5b0fd9",
 		Prover:      &ChaChaOPRFProver{},
 	},
 	"aes-128-ctr-toprf": {
-		KeyHash:     "fe380af3f8a4026d214c023c3d31a14ca2e560d0361721a7b1edb97d6b9db3d4",
-		CircuitHash: "3d6fd6cc53bb465300785201abbb0987d1ef9ebe0400ec6107fdfa81d48c3773",
+		KeyHash:     "aae5e5e48cb75802aef73f8b0e0384d665c4f26e04227352f10a3401767b1986",
+		CircuitHash: "33b0c9bbc6c2a3e322027f48ecc8d20590e44ed772db1a896990c043325ef3e0",
 		Prover:      &AESOPRFProver{},
 	},
 	"aes-256-ctr-toprf": {
-		KeyHash:     "35f6625ce05e41417dbca2fa3aa18a4f43b8973454c0a12847ade67f976fb43b",
-		CircuitHash: "d1e128fcfd2de96d1e296e848998d09988a52bb3bb80a9a9064175cba8e3fe69",
+		KeyHash:     "a3c5c6ef394ac3edb158de12b235bce836bd9c3a0286787c92648bbce8830adb",
+		CircuitHash: "58ba58ff0124a662f6643f5ba081fb88a4f7f5bdadaeddc003fc2cc3e26d8ec2",
 		Prover:      &AESOPRFProver{},
 	},
 }

gnark/libraries/prover/impl/provers.go

@@ -268,7 +268,6 @@ func (cp *ChaChaOPRFProver) Prove(params *InputParams) (proof []byte, output []u
 
 	witness := &chachaV3_oprf.ChachaTOPRFCircuit{
 		TOPRF: toprf.Params{
-			SecretData:      [2]frontend.Variable{0, 0}, // will be rewritten
 			DomainSeparator: new(big.Int).SetBytes(oprf.DomainSeparator),
 			Mask:            new(big.Int).SetBytes(oprf.Mask),
 			Output:          new(big.Int).SetBytes(oprf.Output),
@@ -360,7 +359,6 @@ func (ap *AESOPRFProver) Prove(params *InputParams) (proof []byte, output []uint
 	circuit := &aes_v2_oprf.AESTOPRFCircuit{
 		AESBaseCircuit: aes_v2.AESBaseCircuit{Key: make([]frontend.Variable, len(key))},
 		TOPRF: toprf.Params{
-			SecretData:      [2]frontend.Variable{0, 0}, // will be rewritten
 			DomainSeparator: new(big.Int).SetBytes(oprf.DomainSeparator),
 			Mask:            new(big.Int).SetBytes(oprf.Mask),
 			Output:          new(big.Int).SetBytes(oprf.Output),