@ohos-ports/crypto 0.0.0-stage → 0.3.1-beta.1

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2023 Harmonic Laboratories
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,61 @@
-# Temporary Holding Version
+# @harmoniclabs/crypto
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+collection of cryptographic functions that support every js runtime for ES5+
+
+## Disclaimer
+
+The purpose of the library is to guarantee support for any javascript runtime with ES5+.
+
+**THIS IMPLEMENTATION SHOULD NOT BE ASSUMED TO BE SAFE**
+
+If you are in a node js environment you should use the [node crypto native module](https://nodejs.org/api/crypto.html); without doubt more preformant and secure.
+
+## vrf batch verification benchmarks
+
+> NOTE: for batches with 38 elements or more the pippenger multiscalar multiplication should be used
+> 
+> however it seems that there is something wrong wiht the implementation;
+> since pippenger returns false where instead straus returns true (as it should be);
+>
+> for now then all batches sizes do use the straus algorithm, which is not optimal
+>
+> as you can see from the benchmarks, after size 32, the time/proof flattens
+> (or get even worse in the case of bun) 
+
+```
+node --version
+v22.13.1
+```
+
+```
+size:    2; time:     36.216ms; time/proof:   18.108ms result: true
+size:    4; time:     59.885ms; time/proof:   14.971ms result: true
+size:    8; time:    105.061ms; time/proof:   13.133ms result: true
+size:   16; time:    217.173ms; time/proof:   13.573ms result: true
+size:   32; time:    397.940ms; time/proof:   12.436ms result: true
+size:   64; time:    753.830ms; time/proof:   11.779ms result: true
+size:  128; time:   1514.647ms; time/proof:   11.833ms result: true
+size:  256; time:   3118.631ms; time/proof:   12.182ms result: true
+size:  512; time:   6004.233ms; time/proof:   11.727ms result: true
+size: 1024; time:  11948.110ms; time/proof:   11.668ms result: true
+```
+
+> NOTE: bun performs better in basically all cryptography functions except for this specific batch vrf.
+
+```
+bun --version
+1.1.13
+```
+
+```
+size:    2; time:     68.439ms; time/proof:   34.219ms result: true
+size:    4; time:    130.650ms; time/proof:   32.662ms result: true
+size:    8; time:    254.191ms; time/proof:   31.774ms result: true
+size:   16; time:    505.512ms; time/proof:   31.594ms result: true
+size:   32; time:   1001.648ms; time/proof:   31.301ms result: true
+size:   64; time:   1975.420ms; time/proof:   30.866ms result: true
+size:  128; time:   4077.155ms; time/proof:   31.853ms result: true
+size:  256; time:   9204.953ms; time/proof:   35.957ms result: true
+size:  512; time:  18359.952ms; time/proof:   35.859ms result: true
+size: 1024; time:  35875.629ms; time/proof:   35.035ms result: true
+```

package/dist/bech32.d.ts

@@ -0,0 +1,53 @@
+import { byte, uint5 } from "./types.js";
+/**
+ * Expand human readable prefix of the bech32 encoding so it can be used in the checkSum
+ */
+export declare function expandBech32HumanReadablePart(hrp: string): byte[];
+/**
+ * Used as part of the bech32 checksum.
+ */
+export declare function getBech32Polymod(bytes: byte[]): number;
+/**
+ * Generate the bech32 checksum
+ */
+export declare function getBech32Checksum(humanReadablePart: string, data: uint5[]): [uint5, uint5, uint5, uint5, uint5, uint5];
+/**
+ * Creates a bech32 checksummed string (used to represent Cardano addresses)
+ * @example
+ * encodeBech32("foo", textToBytes("foobar")) => "foo1vehk7cnpwgry9h96"
+ * @example
+ * encodeBech32("addr_test", hexToBytes("70a9508f015cfbcffc3d88ac4c1c934b5b82d2bb281d464672f6c49539")) => "addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld"
+ * @param {byte[]} data - uint8 0 - 256
+ */
+export declare function encodeBech32(humanReadablePart: string, data: byte[] | Uint8Array): string;
+/**
+ * Verify a bech32 checksum
+ * @example
+ * isBech32("foo1vehk7cnpwgry9h96") => true
+ * @example
+ * isBech32("foo1vehk7cnpwgry9h97") => false
+ * @example
+ * isBech32("a12uel5l") => true
+ * @example
+ * isBech32("mm1crxm3i") => false
+ * @example
+ * isBech32("A1G7SGD8") => false
+ * @example
+ * isBech32("abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw") => true
+ * @example
+ * isBech32("?1ezyfcl") => true
+ * @example
+ * isBech32("addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld") => true
+ * @param {string} addr
+ * @returns {boolean}
+ */
+export declare function isBech32(addr: string): boolean;
+/**
+ * Decomposes a bech32 checksummed string (i.e. Cardano address), and returns the human readable part and the original bytes
+ * Throws an error if checksum is invalid.
+ * @example
+ * bytesToHex(decodeBech32("addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld")[1]) => "70a9508f015cfbcffc3d88ac4c1c934b5b82d2bb281d464672f6c49539"
+ * @param {string} addr
+ * @returns {[humanReadablePart: string, bytes: byte[]]}
+ */
+export declare function decodeBech32(addr: string): [humanReadablePart: string, bytes: byte[]];

package/dist/bech32.js

@@ -0,0 +1,187 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBech32 = exports.isBech32 = exports.encodeBech32 = exports.getBech32Checksum = exports.getBech32Polymod = exports.expandBech32HumanReadablePart = void 0;
+var uint8array_utils_1 = require("@harmoniclabs/uint8array-utils");
+var types_1 = require("./types.js");
+var base32_1 = require("./utils/base32.js");
+var assert_1 = require("./utils/assert.js");
+/**
+ * Expand human readable prefix of the bech32 encoding so it can be used in the checkSum
+ */
+function expandBech32HumanReadablePart(hrp) {
+    var e_1, _a, e_2, _b;
+    var bytes = [];
+    try {
+        for (var hrp_1 = __values(hrp), hrp_1_1 = hrp_1.next(); !hrp_1_1.done; hrp_1_1 = hrp_1.next()) {
+            var c = hrp_1_1.value;
+            bytes.push(c.charCodeAt(0) >> 5);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (hrp_1_1 && !hrp_1_1.done && (_a = hrp_1.return)) _a.call(hrp_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    bytes.push(0);
+    try {
+        for (var hrp_2 = __values(hrp), hrp_2_1 = hrp_2.next(); !hrp_2_1.done; hrp_2_1 = hrp_2.next()) {
+            var c = hrp_2_1.value;
+            bytes.push(c.charCodeAt(0) & 31);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (hrp_2_1 && !hrp_2_1.done && (_b = hrp_2.return)) _b.call(hrp_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return bytes;
+}
+exports.expandBech32HumanReadablePart = expandBech32HumanReadablePart;
+var BECH32_POLYMOD_GEN = Object.freeze([0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]);
+/**
+ * Used as part of the bech32 checksum.
+ */
+function getBech32Polymod(bytes) {
+    var e_3, _a;
+    var checksum = 1;
+    try {
+        for (var bytes_1 = __values(bytes), bytes_1_1 = bytes_1.next(); !bytes_1_1.done; bytes_1_1 = bytes_1.next()) {
+            var byte_1 = bytes_1_1.value;
+            var c = (checksum >> 25);
+            checksum = (checksum & 0x1fffffff) << 5 ^ byte_1;
+            for (var i = 0; i < 5; i++) {
+                if (((c >> i) & 1) != 0) {
+                    checksum ^= BECH32_POLYMOD_GEN[i];
+                }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (bytes_1_1 && !bytes_1_1.done && (_a = bytes_1.return)) _a.call(bytes_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return checksum;
+}
+exports.getBech32Polymod = getBech32Polymod;
+/**
+ * Generate the bech32 checksum
+ */
+function getBech32Checksum(humanReadablePart, data) {
+    var checksum = getBech32Polymod(expandBech32HumanReadablePart(humanReadablePart)
+        .concat(data)
+        .concat([0, 0, 0, 0, 0, 0])) ^ 1;
+    var chkSum = [];
+    for (var i = 0; i < 6; i++) {
+        chkSum.push((checksum >> 5 * (5 - i)) & 31);
+    }
+    return chkSum;
+}
+exports.getBech32Checksum = getBech32Checksum;
+/**
+ * Creates a bech32 checksummed string (used to represent Cardano addresses)
+ * @example
+ * encodeBech32("foo", textToBytes("foobar")) => "foo1vehk7cnpwgry9h96"
+ * @example
+ * encodeBech32("addr_test", hexToBytes("70a9508f015cfbcffc3d88ac4c1c934b5b82d2bb281d464672f6c49539")) => "addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld"
+ * @param {byte[]} data - uint8 0 - 256
+ */
+function encodeBech32(humanReadablePart, data) {
+    (0, assert_1.assert)(humanReadablePart.length > 0, "human-readable-part must have non-zero length");
+    var _data = (0, types_1.buffToUint5Arr)((0, uint8array_utils_1.isUint8Array)(data) ? data : new Uint8Array(data));
+    return humanReadablePart + "1" +
+        _data.concat(getBech32Checksum(humanReadablePart, _data)).map(function (val) { return base32_1.BECH32_BASE32_ALPHABET[val]; }).join("");
+}
+exports.encodeBech32 = encodeBech32;
+/**
+ * Verify a bech32 checksum
+ * @example
+ * isBech32("foo1vehk7cnpwgry9h96") => true
+ * @example
+ * isBech32("foo1vehk7cnpwgry9h97") => false
+ * @example
+ * isBech32("a12uel5l") => true
+ * @example
+ * isBech32("mm1crxm3i") => false
+ * @example
+ * isBech32("A1G7SGD8") => false
+ * @example
+ * isBech32("abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw") => true
+ * @example
+ * isBech32("?1ezyfcl") => true
+ * @example
+ * isBech32("addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld") => true
+ * @param {string} addr
+ * @returns {boolean}
+ */
+function isBech32(addr) {
+    var e_4, _a;
+    var i = addr.lastIndexOf("1");
+    if (i == -1 || i == 0) {
+        return false;
+    }
+    var hrp = addr.slice(0, i);
+    addr = addr.slice(i + 1);
+    var data = [];
+    try {
+        for (var addr_1 = __values(addr), addr_1_1 = addr_1.next(); !addr_1_1.done; addr_1_1 = addr_1.next()) {
+            var ch = addr_1_1.value;
+            var j = base32_1.BECH32_BASE32_ALPHABET.indexOf(ch);
+            if (j == -1) {
+                return false;
+            }
+            data.push(j);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (addr_1_1 && !addr_1_1.done && (_a = addr_1.return)) _a.call(addr_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    var chkSumA = data.slice(data.length - 6);
+    var chkSumB = getBech32Checksum(hrp, data.slice(0, data.length - 6));
+    for (var i_1 = 0; i_1 < 6; i_1++) {
+        if (chkSumA[i_1] != chkSumB[i_1]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isBech32 = isBech32;
+/**
+ * Decomposes a bech32 checksummed string (i.e. Cardano address), and returns the human readable part and the original bytes
+ * Throws an error if checksum is invalid.
+ * @example
+ * bytesToHex(decodeBech32("addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld")[1]) => "70a9508f015cfbcffc3d88ac4c1c934b5b82d2bb281d464672f6c49539"
+ * @param {string} addr
+ * @returns {[humanReadablePart: string, bytes: byte[]]}
+ */
+function decodeBech32(addr) {
+    (0, assert_1.assert)(isBech32(addr), "invalid bech32 addr");
+    var i = addr.lastIndexOf("1");
+    (0, assert_1.assert)(i != -1, "bech32 address missing the '1' separator");
+    var hrp = addr.slice(0, i);
+    addr = addr.slice(i + 1);
+    var data = (0, base32_1.decodeBase32Bech32)(addr.slice(0, addr.length - 6));
+    return [hrp, Array.from(data)];
+}
+exports.decodeBech32 = decodeBech32;

package/dist/blake2b.d.ts

@@ -0,0 +1,7 @@
+import type { byte } from "./types.js";
+export type SupportedDigestSize = 16 | 28 | 32 | 64;
+export declare function blake2b(data: byte[] | Uint8Array, digestSize?: SupportedDigestSize): Uint8Array;
+export declare function blake2b_128(data: byte[] | Uint8Array): Uint8Array;
+export declare function blake2b_224(data: byte[] | Uint8Array): Uint8Array;
+export declare function blake2b_256(data: byte[] | Uint8Array): Uint8Array;
+export declare function blake2b_512(data: byte[] | Uint8Array): Uint8Array;

package/dist/blake2b.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blake2b_512 = exports.blake2b_256 = exports.blake2b_224 = exports.blake2b_128 = exports.blake2b = void 0;
+/**
+ * 64-bit unsigned addition
+ * Sets v[a,a+1] += v[b,b+1]
+ * v should be a Uint32Array
+ */
+function ADD64AA(v, a, b) {
+    var o0 = v[a] + v[b];
+    var o1 = v[a + 1] + v[b + 1];
+    if (o0 >= 0x100000000) {
+        o1++;
+    }
+    v[a] = o0;
+    v[a + 1] = o1;
+}
+// 64-bit unsigned addition
+// Sets v[a,a+1] += b
+// b0 is the low 32 bits of b, b1 represents the high 32 bits
+function ADD64AC(v, a, b0, b1) {
+    var o0 = v[a] + b0;
+    if (b0 < 0) {
+        o0 += 0x100000000;
+    }
+    var o1 = v[a + 1] + b1;
+    if (o0 >= 0x100000000) {
+        o1++;
+    }
+    v[a] = o0;
+    v[a + 1] = o1;
+}
+// Little-endian byte access
+function B2B_GET32(arr, i) {
+    return arr[i] ^ (arr[i + 1] << 8) ^ (arr[i + 2] << 16) ^ (arr[i + 3] << 24);
+}
+// G Mixing function
+// The ROTRs are inlined for speed
+function B2B_G(a, b, c, d, ix, iy) {
+    var x0 = m[ix];
+    var x1 = m[ix + 1];
+    var y0 = m[iy];
+    var y1 = m[iy + 1];
+    ADD64AA(v, a, b); // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
+    ADD64AC(v, a, x0, x1); // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
+    // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
+    var xor0 = v[d] ^ v[a];
+    var xor1 = v[d + 1] ^ v[a + 1];
+    v[d] = xor1;
+    v[d + 1] = xor0;
+    ADD64AA(v, c, d);
+    // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
+    xor0 = v[b] ^ v[c];
+    xor1 = v[b + 1] ^ v[c + 1];
+    v[b] = (xor0 >>> 24) ^ (xor1 << 8);
+    v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8);
+    ADD64AA(v, a, b);
+    ADD64AC(v, a, y0, y1);
+    // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
+    xor0 = v[d] ^ v[a];
+    xor1 = v[d + 1] ^ v[a + 1];
+    v[d] = (xor0 >>> 16) ^ (xor1 << 16);
+    v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16);
+    ADD64AA(v, c, d);
+    // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
+    xor0 = v[b] ^ v[c];
+    xor1 = v[b + 1] ^ v[c + 1];
+    v[b] = (xor1 >>> 31) ^ (xor0 << 1);
+    v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1);
+}
+// Initialization Vector
+var BLAKE2B_IV32 = new Uint32Array([
+    0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372,
+    0x5f1d36f1, 0xa54ff53a, 0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c,
+    0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19
+]);
+var SIGMA8 = [
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13,
+    6, 1, 12, 0, 2, 11, 7, 5, 3, 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1,
+    9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4,
+    10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5,
+    15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11, 13, 11, 7,
+    14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2,
+    13, 7, 1, 4, 10, 5, 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0, 0,
+    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6,
+    1, 12, 0, 2, 11, 7, 5, 3
+];
+// These are offsets into a uint64 buffer.
+// Multiply them all by 2 to make them offsets into a uint32 buffer,
+// because this is Javascript and we don't have uint64s
+var SIGMA82 = new Uint8Array(SIGMA8.map(function (x) {
+    return x * 2;
+}));
+// Compression function. 'last' flag indicates last block.
+// Note we're representing 16 uint64s as 32 uint32s
+var v = new Uint32Array(32);
+var m = new Uint32Array(32);
+function blake2bCompress(ctx, last) {
+    var i = 0;
+    // init work variables
+    for (i = 0; i < 16; i++) {
+        v[i] = ctx.h[i];
+        v[i + 16] = BLAKE2B_IV32[i];
+    }
+    // low 64 bits of offset
+    v[24] = v[24] ^ ctx.t;
+    v[25] = v[25] ^ (ctx.t / 0x100000000);
+    // high 64 bits not supported, offset may not be higher than 2**53-1
+    // last block flag set ?
+    if (last) {
+        v[28] = ~v[28];
+        v[29] = ~v[29];
+    }
+    // get little-endian words
+    for (i = 0; i < 32; i++) {
+        m[i] = B2B_GET32(ctx.b, 4 * i);
+    }
+    // twelve rounds of mixing
+    // uncomment the DebugPrint calls to log the computation
+    // and match the RFC sample documentation
+    // util.debugPrint('          m[16]', m, 64)
+    for (i = 0; i < 12; i++) {
+        // util.debugPrint('   (i=' + (i < 10 ? ' ' : '') + i + ') v[16]', v, 64)
+        B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
+        B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
+        B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
+        B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
+        B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
+        B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
+        B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
+        B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
+    }
+    // util.debugPrint('   (i=12) v[16]', v, 64)
+    for (i = 0; i < 16; i++) {
+        ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
+    }
+    // util.debugPrint('h[8]', ctx.h, 64)
+}
+/** reusable parameterBlock */
+var parameterBlock = new Uint8Array(64).fill(0);
+function blake2bInit(digestSize) {
+    // state, 'param block'
+    var ctx = {
+        b: new Uint8Array(128),
+        h: new Uint32Array(16),
+        t: 0,
+        c: 0,
+        digestSize: digestSize // output length in bytes
+    };
+    // initialize parameterBlock before usage
+    parameterBlock.fill(0);
+    parameterBlock[0] = digestSize;
+    parameterBlock[2] = 1; // fanout
+    parameterBlock[3] = 1; // depth
+    // initialize hash state
+    for (var i = 0; i < 16; i++) {
+        ctx.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameterBlock, i * 4);
+    }
+    return ctx;
+}
+// Updates a BLAKE2b streaming hash
+// Requires hash context and Uint8Array (byte array)
+function blake2bUpdate(ctx, input) {
+    for (var i = 0; i < input.length; i++) {
+        if (ctx.c === 128) {
+            // buffer full ?
+            ctx.t += ctx.c; // add counters
+            blake2bCompress(ctx, false); // compress (not last)
+            ctx.c = 0; // counter to zero
+        }
+        ctx.b[ctx.c++] = input[i];
+    }
+}
+// Completes a BLAKE2b streaming hash
+// Returns a Uint8Array containing the message digest
+function blake2bFinal(ctx) {
+    ctx.t += ctx.c; // mark last block offset
+    while (ctx.c < 128) {
+        // fill up with zeros
+        ctx.b[ctx.c++] = 0;
+    }
+    blake2bCompress(ctx, true); // final block flag = 1
+    // little endian convert and store
+    var out = new Uint8Array(ctx.digestSize);
+    for (var i = 0; i < ctx.digestSize; i++) {
+        out[i] = ctx.h[i >> 2] >> (8 * (i & 3));
+    }
+    return out;
+}
+function blake2b(data, digestSize) {
+    if (digestSize === void 0) { digestSize = 32; }
+    data = new Uint8Array(data);
+    var ctx = blake2bInit(digestSize);
+    blake2bUpdate(ctx, data);
+    return blake2bFinal(ctx);
+}
+exports.blake2b = blake2b;
+function blake2b_128(data) {
+    return blake2b(data, 16);
+}
+exports.blake2b_128 = blake2b_128;
+function blake2b_224(data) {
+    return blake2b(data, 28);
+}
+exports.blake2b_224 = blake2b_224;
+function blake2b_256(data) {
+    return blake2b(data, 32);
+}
+exports.blake2b_256 = blake2b_256;
+function blake2b_512(data) {
+    return blake2b(data, 64);
+}
+exports.blake2b_512 = blake2b_512;

package/dist/bls12_318.d.ts

@@ -0,0 +1,48 @@
+import { ProjConstructor } from "./noble/curves/weierstrass.js";
+export declare const BlsG1: ProjConstructor<bigint>;
+export declare const BlsG2: ProjConstructor<{
+    c0: bigint;
+    c1: bigint;
+}>;
+export declare function isBlsG1(stuff: any): stuff is BlsG1;
+export declare function isBlsG2(stuff: any): stuff is BlsG2;
+type UnwrapProjConstructor<Stuff extends ProjConstructor<any>> = Stuff extends ProjConstructor<infer T> ? T : never;
+export type Fp2 = UnwrapProjConstructor<typeof BlsG2>;
+export declare function isFp2(stuff: any): stuff is Fp2;
+type ConstructorReturnType<CtorLike extends {
+    new (...args: any): any;
+}> = CtorLike extends {
+    new (...args: any): infer ReturnT;
+} ? ReturnT : never;
+export type BlsG1 = ConstructorReturnType<typeof BlsG1>;
+export type BlsG2 = ConstructorReturnType<typeof BlsG2>;
+export declare function bls12_381_G1_add(a: BlsG1, b: BlsG1): BlsG1;
+export declare function bls12_381_G1_neg(elem: BlsG1): BlsG1;
+export declare function bls12_381_G1_scalarMul(n: number | bigint, g1: BlsG1): BlsG1;
+export declare function bls12_381_G1_equal(a: BlsG1, b: BlsG1): boolean;
+export declare function bls12_381_G1_hashToGroup(a: Uint8Array, b: Uint8Array): BlsG1;
+export declare function bls12_381_G1_compress(elem: BlsG1): Uint8Array;
+export declare function bls12_381_G1_uncompress(compressed: Uint8Array): BlsG1;
+export declare function bls12_381_G2_add(a: BlsG2, b: BlsG2): BlsG2;
+export declare function bls12_381_G2_neg(elem: BlsG2): BlsG2;
+export declare function bls12_381_G2_scalarMul(n: number | bigint, g2: BlsG2): BlsG2;
+export declare function bls12_381_G2_equal(a: BlsG2, b: BlsG2): boolean;
+export declare function bls12_381_G2_hashToGroup(a: Uint8Array, b: Uint8Array): BlsG2;
+export declare function bls12_381_G2_compress(elem: BlsG2): Uint8Array;
+export declare function bls12_381_G2_uncompress(compressed: Uint8Array): BlsG2;
+export declare function bls12_381_millerLoop(g1: BlsG1, g2: BlsG2): BlsResult;
+export declare function bls12_381_mulMlResult(a: BlsResult, b: BlsResult): BlsResult;
+export declare const bls12_381_eqMlResult: (a: BlsResult, b: BlsResult) => boolean;
+export declare function bls12_381_finalVerify(a: BlsResult, b: BlsResult): boolean;
+export type BlsResult = {
+    c0: Fp6_t;
+    c1: Fp6_t;
+};
+export declare function isBlsResult(stuff: any): stuff is BlsResult;
+type Fp6_t = {
+    c0: Fp2;
+    c1: Fp2;
+    c2: Fp2;
+};
+export declare function isFp6(stuff: any): stuff is Fp6_t;
+export {};