wip: refactor the refactor (#50)

* add blst/ to .gitignore

* fix test

* feat: remove sig_groupcheck

* fix(testSets): SECRET_KEY_LENGTH -> SECRET_KEY_SIZE

* fix(index): remove missing verify.js

* rebirth

* chore: a bit more restructuring on zig

* more updates

* feat: implement verifyMultipleAggregateSignatures

* remove redundant log

* chore: simplify signature and pk size consts

* update aggregateWithRandomness with writing pks and sigs

* simple test for AggregateSignature

* revert some changes

* fix(sig): fix fromBytes

* update bindings

* fix(verifyMultipleAggSigs): fix writers for
verifyMultipleAggregateSignatures

* uncomment tests

* missing *Signature

* chore(signature): remove unused sigValidate

* fix(signature.ts): do fromBytes first then validate

* fix test

* fix randomness

* fix: uncomment aggregateVerify test

* chore: simplify naming for signature length constants

* remove unused code

* add writeSignatures

* more test fixes

* test(pk): add test for aggregatePublicKeys

* define and use MAX_AGGREGATE_PER_JOB

* use pointers to PublicKey in aggregatePublicKey

* fix length for aggregate signatures

* remove redundant print

* AggregateSignature: fix rands input for aggregateWithRandomness

* fix scratch for aggsig and aggpk

* remove comment

* uncomment more checks

* chore: remove redundant SignatureSet

* fix rands input to aggregateWithRandomness

* fix stuff related to rands

* fixes

* remove redundant c abi code; mostly unused stuff

* update README

* chore(error): remove redundant error definitions

* chore(aggPk): cleanup AggregatePublicKey.zig

* small correciton

* more minor changes to aggPk

* chore(aggSig): doc comment and tidy up

* add dst as a const

* fix link for DST

* doc comments for pairing.zig

* finish doc comments

* fix comment

* remove comment

* remove unnecessary import

Author: spiral-ladder

.gitignore

@@ -1,4 +1,5 @@
 zig-out/
 .zig-cache/
 bun/node_modules/
-bun/benchmark_data/
+bun/benchmark_data/
+blst/

README.md

@@ -1,16 +1,45 @@
 # blst-z
-Zig wrapper for [supranational/blst](https://github.com/supranational/blst) native bindings, a highly performant BLS12-381 signature library.
+Zig bindings for [supranational's blst](https://github.com/supranational/blst) native bindings, a highly performant BLS12-381 signature library.
+
+This set of bindings only support the `min_pk` variant.
 
 ## Installation
-- clone blst to root: `git clone --recurse-submodules https://github.com/supranational/blst.git`
-- `zig build test`
+
+First, clone [blst](https://github.com/supranational/blst.git) to root:
+
+```sh
+git clone --recurse-submodules https://github.com/supranational/blst.git
+```
+
+Run zig tests:
+
+```sh
+zig build test
+```
+
+Install and generate bun bindings:
+
+```console
+cd bun && bun install && bun run build && bun generate
+```
+
+Run bun tests:
+
+```sh
+cd bun && bun test
+```
+
+Run bun benchmarks:
+
+```sh
+cd bun && bun benchmark 
+```
 
 ## Usage
-The below shows how to use min_pk namespace, should be the same for min_sig.
 
 ```zig
-pub const min_pk = @import("blst").min_pk;
-const SecretKey = min_pk.SecretKey;
+pub const blst = @import("blst");
+const SecretKey = blst.SecretKey;
 const ikm: [32]u8 = [_]u8{
     0x93, 0xad, 0x7e, 0x65, 0xde, 0xad, 0x05, 0x2a, 0x08, 0x3a,
     0x91, 0x0c, 0x8b, 0x72, 0x85, 0x91, 0x46, 0x4c, 0xca, 0x56,
@@ -27,4 +56,4 @@ const sig = sk.sign(msg[0..], dst[0..], null);
 
 // aug is null
 try sig.verify(true, msg[0..], dst[0..], null, &pk, true);
-```
+```

bun/package.json

@@ -30,7 +30,7 @@
 		"benchmark:files": "bun ./node_modules/.bin/benchmark --config .benchrc.yaml --defaultBranch main"
 	},
 	"bun-ffi-z": {
-		"name": "blst_min_pk",
+		"name": "eth_blst",
 		"targets": [
 			"linux-x64-gnu",
 			"linux-arm64-gnu",

bun/src/aggregate.ts

@@ -1,12 +1,13 @@
 import {binding} from "./binding.js";
-import {MAX_AGGREGATE_PER_JOB} from "./const.js";
-import {PublicKey, writePublicKeysReference} from "./publicKey.js";
-import {Signature, writeSignaturesReference} from "./signature.js";
+import {MAX_AGGREGATE_PER_JOB, PUBLIC_KEY_SIZE, SIGNATURE_LENGTH} from "./const.js";
+import {PublicKey} from "./publicKey.js";
+import {writeSignaturesReference, writePublicKeysReference, writeUint8ArrayArray} from "./writers.ts";
+import {writePublicKeys, pksU8, writeSignatures, sigsU8} from "./buffer.ts";
+import {Signature} from "./signature.js";
 
 // global public keys reference to be reused across multiple calls
 // each 2 items are 8 bytes, store the reference of each public key
 const publicKeysRef = new Uint32Array(MAX_AGGREGATE_PER_JOB * 2);
-
 const signaturesRef = new Uint32Array(MAX_AGGREGATE_PER_JOB * 2);
 
 /**
@@ -15,6 +16,7 @@ const signaturesRef = new Uint32Array(MAX_AGGREGATE_PER_JOB * 2);
  * If `pks_validate` is `true`, the public keys will be infinity and group checked.
  */
 export function aggregatePublicKeys(pks: Array<PublicKey>, pksValidate?: boolean | undefined | null): PublicKey {
+
 	if (pks.length === 0) {
 		throw new Error("At least one public key is required");
 	}
@@ -23,16 +25,17 @@ export function aggregatePublicKeys(pks: Array<PublicKey>, pksValidate?: boolean
 
 	for (let i = 0; i < pks.length; i += MAX_AGGREGATE_PER_JOB) {
 		const pksBatch = pks.slice(i, Math.min(pks.length, i + MAX_AGGREGATE_PER_JOB));
-		const pksRef = writePublicKeysReference(pksBatch);
-		const outPk = PublicKey.defaultPublicKey();
-		const res = binding.aggregatePublicKeys(outPk.ptr, pksRef, pksBatch.length, pksValidate ?? false);
+		writePublicKeys(pksBatch);
+		const outPk = new PublicKey(new Uint8Array(PUBLIC_KEY_SIZE));
+		const res = binding.publicKeyAggregate(outPk.ptr, pksU8, pksBatch.length, pksValidate ?? false);
 
 		if (res !== 0) {
 			throw new Error(`Failed to aggregate public keys: ${res}`);
 		}
 		resultPks.push(outPk);
 	}
 
+
 	return resultPks.length === 1 ? resultPks[0] : aggregatePublicKeys(resultPks, pksValidate);
 }
 
@@ -50,9 +53,9 @@ export function aggregateSignatures(sigs: Array<Signature>, sigsGroupcheck?: boo
 
 	for (let i = 0; i < sigs.length; i += MAX_AGGREGATE_PER_JOB) {
 		const sigsBatch = sigs.slice(i, Math.min(sigs.length, i + MAX_AGGREGATE_PER_JOB));
-		const sigsRef = writeSignaturesReference(sigsBatch);
-		const outSig = Signature.defaultSignature();
-		const res = binding.aggregateSignatures(outSig.ptr, sigsRef, sigsBatch.length, sigsGroupcheck ?? false);
+		writeSignatures(sigsBatch);
+		const outSig = new Signature(new Uint8Array(SIGNATURE_LENGTH));
+		const res = binding.signatureAggregate(outSig.ptr, sigsU8, sigsBatch.length, sigsGroupcheck ?? false);
 
 		if (res !== 0) {
 			throw new Error(`Failed to aggregate signatures: ${res}`);
@@ -81,8 +84,8 @@ export function aggregateSerializedPublicKeys(
 	for (let i = 0; i < pks.length; i += MAX_AGGREGATE_PER_JOB) {
 		const pksBatch = pks.slice(i, Math.min(pks.length, i + MAX_AGGREGATE_PER_JOB));
 		const pksRef = writeSerializedPublicKeysReference(pksBatch);
-		const outPk = PublicKey.defaultPublicKey();
-		const res = binding.aggregateSerializedPublicKeys(
+		const outPk = new PublicKey(new Uint8Array(PUBLIC_KEY_SIZE));
+		const res = binding.aggregatePublicKeys(
 			outPk.ptr,
 			pksRef,
 			pksBatch.length,
@@ -117,12 +120,11 @@ export function aggregateSerializedSignatures(
 	for (let i = 0; i < sigs.length; i += MAX_AGGREGATE_PER_JOB) {
 		const sigsBatch = sigs.slice(i, Math.min(sigs.length, i + MAX_AGGREGATE_PER_JOB));
 		const sigsRef = writeSerializedSignaturesReference(sigsBatch);
-		const outSig = Signature.defaultSignature();
-		const res = binding.aggregateSerializedSignatures(
+		const outSig = new Signature(new Uint8Array(SIGNATURE_LENGTH));
+		const res = binding.signatureAggregate(
 			outSig.ptr,
 			sigsRef,
 			sigsBatch.length,
-			sigs[0].length,
 			sigsGroupcheck ?? false
 		);
 
@@ -132,7 +134,7 @@ export function aggregateSerializedSignatures(
 		resultSignatures.push(outSig);
 	}
 
-	return resultSignatures.length === 1 ? resultSignatures[0] : aggregateSignatures(resultSignatures, sigsGroupcheck);
+	return resultSignatures.length === 1 ? resultSignatures[0] : aggregateSerializedSignatures(resultSignatures, sigsGroupcheck);
 }
 
 function writeSerializedPublicKeysReference(pks: Uint8Array[]): Uint32Array {

bun/src/aggregateWithRandomness.ts

@@ -1,6 +1,8 @@
 import {JSCallback} from "bun:ffi";
-import {binding, writeNumber, writeReference} from "./binding.js";
-import {MAX_AGGREGATE_WITH_RANDOMNESS_PER_JOB} from "./const.js";
+import {binding} from "./binding.js";
+import {writePublicKeys, pksU8} from "./buffer.ts";
+import {writeReference, writePublicKeysReference, writeSignaturesReference} from "./writers.ts";
+import {MAX_AGGREGATE_WITH_RANDOMNESS_PER_JOB, PUBLIC_KEY_SIZE, SIGNATURE_LENGTH} from "./const.js";
 import {PublicKey} from "./publicKey.js";
 import {Signature} from "./signature.js";
 
@@ -33,15 +35,17 @@ export function aggregateWithRandomness(sets: Array<PkAndSerializedSig>): PkAndS
 		throw new Error("At least one PkAndSerializedSig is required");
 	}
 
-	const refs = pkAndSerializedSigsRefs.subarray(0, sets.length * 2);
-	writePkAndSerializedSigsReference(sets, refs);
-	const pkOut = PublicKey.defaultPublicKey();
-	const sigOut = Signature.defaultSignature();
 
-	const res = binding.aggregateWithRandomness(refs, sets.length, pkOut.ptr, sigOut.ptr);
+	const pksRef = writePublicKeysReference(sets.map(s => s.pk));
+	const sigsRef = writeSignaturesReference(sets.map(s => Signature.fromBytes(s.sig, true)));
+	const pkOut = new PublicKey(new Uint8Array(PUBLIC_KEY_SIZE));
+	const sigOut = new Signature(new Uint8Array(SIGNATURE_LENGTH));
 
-	if (res !== 0) {
-		throw new Error("Failed to aggregate with randomness res = " + res);
+	const resSig = binding.signatureAggregateWithRandomness(sigOut.ptr, sigsRef, sets.length, false);
+	const resPk = binding.publicKeyAggregateWithRandomness(pkOut.ptr, pksRef, sets.length, false);
+
+	if (resSig !== 0 || resPk !== 0) {
+		throw new Error("Failed to aggregate with randomness res = " + resSig + resPk);
 	}
 
 	return {pk: pkOut, sig: sigOut};
@@ -69,8 +73,8 @@ export function asyncAggregateWithRandomness(sets: Array<PkAndSerializedSig>): P
 
 	// 1s timeout
 	const TIMEOUT_MS = 1_000;
-	const pkOut = PublicKey.defaultPublicKey();
-	const sigOut = Signature.defaultSignature();
+	const pkOut = new PublicKey(new Uint8Array(PUBLIC_KEY_SIZE));
+	const sigOut = new Signature(new Uint8Array(SIGNATURE_LENGTH));
 
 	return new Promise((resolve, reject) => {
 		let jscallback: JSCallback | null = null;
@@ -111,7 +115,7 @@ export function asyncAggregateWithRandomness(sets: Array<PkAndSerializedSig>): P
 		const refs = new Uint32Array(sets.length * 2);
 		writePkAndSerializedSigsReference(sets, refs);
 
-		const res = binding.asyncAggregateWithRandomness(
+		const res = binding.aggregateWithRandomness(
 			refs,
 			sets.length,
 			pkOut.ptr,
@@ -156,7 +160,7 @@ function writePkAndSerializedSigsReference(sets: PkAndSerializedSig[], out: Uint
  *
  */
 function writePkAndSerializedSigReference(set: PkAndSerializedSig, out: Uint32Array, offset: number): void {
-	set.pk.writeReference(out, offset);
+	writeReference(set.pk, out, offset);
 	writeReference(set.sig, out, offset + 2);
 	writeNumber(set.sig.length, out, offset + 4);
 }