cafe-utility 26.0.0 → 26.1.1

package/index.d.ts

@@ -503,6 +503,7 @@ declare function uint256ToNumber(bytes: Uint8Array, endian: 'LE' | 'BE'): bigint
 declare function sliceBytes(bytes: Uint8Array, lengths: number[]): Uint8Array[];
 declare function partition(bytes: Uint8Array, size: number): Uint8Array[];
 declare function keccak256(bytes: Uint8Array): Uint8Array;
+declare function sha3_256(bytes: Uint8Array): Uint8Array;
 interface Uint8ArrayIO {
     max: () => number;
 }
@@ -523,12 +524,11 @@ declare class Uint8ArrayWriter implements Uint8ArrayIO {
 declare class Chunk {
     span: bigint;
     writer: Uint8ArrayWriter;
-    hashFn: (a: Uint8Array, b: Uint8Array) => Uint8Array;
-    constructor(capacity: number, hashFn: (a: Uint8Array, b: Uint8Array) => Uint8Array, span?: bigint);
+    constructor(capacity: number, span?: bigint);
     build(): Uint8Array;
     hash(): Uint8Array;
 }
-declare function merkleStart(capacity: number, hashFn: (a: Uint8Array, b: Uint8Array) => Uint8Array): Chunk[];
+declare function merkleStart(capacity: number): Chunk[];
 declare function merkleAppend(levels: Chunk[], data: Uint8Array, onChunk: (chunk: Chunk) => Promise<void>, level?: number): Promise<Chunk[]>;
 declare function merkleFinalize(levels: Chunk[], onChunk: (chunk: Chunk) => Promise<void>, level?: number): Promise<Chunk>;
 type Playbook<T> = {
@@ -611,6 +611,7 @@ export declare const Binary: {
     uint256ToNumber: typeof uint256ToNumber;
     sliceBytes: typeof sliceBytes;
     keccak256: typeof keccak256;
+    sha3_256: typeof sha3_256;
 };
 export declare const Random: {
     intBetween: typeof intBetween;

package/index.js

@@ -2308,22 +2308,22 @@ function bytesToNumbers(n) {
     for (let t = 0; t < n.length; t += 4) e.push(n[t] | (n[t + 1] << 8) | (n[t + 2] << 16) | (n[t + 3] << 24))
     return e
 }
-function divideToBlocks(n) {
+function divideToBlocks(n, e) {
     if (!n.length) {
-        const r = new Uint8Array(136)
-        return (r[0] = 1), (r[135] = 128), [bytesToNumbers(r)]
+        const o = new Uint8Array(136)
+        return (o[0] = e), (o[135] = 128), [bytesToNumbers(o)]
     }
-    const e = partition(n, 136),
-        t = e[e.length - 1]
-    if (t.length < 136) {
-        const r = new Uint8Array(136)
-        r.set(t), (r[t.length] = 1), (r[135] |= 128), (e[e.length - 1] = r)
+    const t = partition(n, 136),
+        r = t[t.length - 1]
+    if (r.length < 136) {
+        const o = new Uint8Array(136)
+        o.set(r), (o[r.length] = e), (o[135] |= 128), (t[t.length - 1] = o)
     }
-    if (t.length === 136) {
-        const r = new Uint8Array(136)
-        ;(r[0] = 1), (r[135] = 128), e.push(r)
+    if (r.length === 136) {
+        const o = new Uint8Array(136)
+        ;(o[0] = e), (o[135] = 128), t.push(o)
     }
-    return e.map(bytesToNumbers)
+    return t.map(bytesToNumbers)
 }
 function absorb(n, e) {
     for (const t of e) {
@@ -2369,7 +2369,10 @@ function squeeze(n) {
     ])
 }
 function keccak256(n) {
-    return squeeze(absorb(new Array(50).fill(0), divideToBlocks(n)))
+    return squeeze(absorb(new Array(50).fill(0), divideToBlocks(n, 1)))
+}
+function sha3_256(n) {
+    return squeeze(absorb(new Array(50).fill(0), divideToBlocks(n, 6)))
 }
 class Uint8ArrayReader {
     constructor(e) {
@@ -2396,25 +2399,25 @@ class Uint8ArrayWriter {
     }
 }
 class Chunk {
-    constructor(e, t, r = 0n) {
-        ;(this.span = r), (this.writer = new Uint8ArrayWriter(new Uint8Array(e))), (this.hashFn = t)
+    constructor(e, t = 0n) {
+        ;(this.span = t), (this.writer = new Uint8ArrayWriter(new Uint8Array(e)))
     }
     build() {
         return concatBytes(numberToUint64(this.span, 'LE'), this.writer.buffer)
     }
     hash() {
-        const e = log2Reduce(partition(this.writer.buffer, 32), this.hashFn)
-        return this.hashFn(numberToUint64(this.span, 'LE'), e)
+        const e = log2Reduce(partition(this.writer.buffer, 32), keccak256)
+        return keccak256(concatBytes(numberToUint64(this.span, 'LE'), e))
     }
 }
-function merkleStart(n, e) {
-    return [new Chunk(n, e)]
+function merkleStart(n) {
+    return [new Chunk(n)]
 }
 async function merkleElevate(n, e, t) {
     await e(n[t]),
-        n[t + 1] || n.push(new Chunk(n[t].writer.buffer.length, n[t].hashFn, n[t].span)),
+        n[t + 1] || n.push(new Chunk(n[t].writer.buffer.length, n[t].span)),
         merkleAppend(n, n[t].hash(), e, t + 1),
-        (n[t] = new Chunk(n[t].writer.buffer.length, n[t].hashFn))
+        (n[t] = new Chunk(n[t].writer.buffer.length))
 }
 async function merkleAppend(n, e, t, r = 0) {
     n[r].writer.max() === 0 && (await merkleElevate(n, t, r))
@@ -2723,7 +2726,8 @@ class AsyncQueue {
         numberToUint256,
         uint256ToNumber,
         sliceBytes,
-        keccak256
+        keccak256,
+        sha3_256
     }),
     (exports.Random = {
         intBetween,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cafe-utility",
-    "version": "26.0.0",
+    "version": "26.1.1",
     "description": "",
     "main": "index.js",
     "exports": {