functionalscript 0.2.0 → 0.2.2

package/out/prime_field/module.f.mjs

@@ -0,0 +1,87 @@
+// @ts-self-types="./module.f.d.mts"
+import * as Operator from '../types/function/operator/module.f.mjs';
+import * as bi from '../types/bigint/module.f.mjs';
+const { scalar_mul } = bi;
+/** @typedef {Operator.Reduce<bigint>} Reduce */
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
+/**
+ * @typedef {{
+ *  readonly p: bigint
+ *  readonly middle: bigint
+ *  readonly max: bigint
+ *  readonly neg: Unary
+ *  readonly sub: Reduce
+ *  readonly add: Reduce
+ *  readonly abs: Unary
+ *  readonly mul: Reduce
+ *  readonly reciprocal: Unary
+ *  readonly div: Reduce
+ *  readonly pow: Reduce
+ *  readonly pow2: Unary
+ *  readonly pow3: Unary
+ * }} PrimeField
+ */
+/** @type {(p: bigint) => PrimeField} */
+export const prime_field = p => {
+    /** @type {Reduce} */
+    const sub = a => b => {
+        const r = a - b;
+        return r < 0 ? r + p : r;
+    };
+    /** @type {Reduce} */
+    const mul = a => b => a * b % p;
+    /** @type {Unary} */
+    const reciprocal = a => {
+        if (a === 0n) {
+            throw '1/0';
+        }
+        let a1 = a;
+        let a0 = p;
+        let f0 = 0n;
+        let f1 = 1n;
+        while (a1 !== 1n) {
+            const q = a0 / a1;
+            const a2 = a0 % a1;
+            a0 = a1;
+            a1 = a2;
+            const f2 = sub(f0)(mul(f1)(q));
+            f0 = f1;
+            f1 = f2;
+        }
+        return f1;
+    };
+    const middle = p >> 1n;
+    /** @type {Unary} */
+    const pow2 = a => mul(a)(a);
+    /** @type {Reduce} */
+    const pow = scalar_mul({ 0: 1n, add: mul });
+    return {
+        p,
+        middle,
+        max: p - 1n,
+        neg: a => a === 0n ? 0n : p - a,
+        sub,
+        add: a => b => {
+            const r = a + b;
+            return r < p ? r : r - p;
+        },
+        abs: a => middle < a ? p - a : a,
+        mul,
+        reciprocal,
+        div: a => b => mul(a)(reciprocal(b)),
+        pow,
+        pow2,
+        pow3: a => mul(a)(pow2(a))
+    };
+};
+/** @type {(f: PrimeField) => (a: bigint) => bigint|null} */
+export const sqrt = ({ p, mul, pow }) => {
+    if ((p & 3n) !== 3n) {
+        throw 'sqrt';
+    }
+    const sqrt_k = (p + 1n) >> 2n;
+    return a => {
+        const result = pow(a)(sqrt_k);
+        return mul(result)(result) === a ? result : null;
+    };
+};

package/out/prime_field/test.f.mjs

@@ -0,0 +1,145 @@
+import * as _ from './module.f.mjs';
+const { prime_field, sqrt } = _;
+export default {
+    prime_field_test: () => {
+        const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
+        const f = prime_field(p);
+        const sqrt_f = sqrt(f);
+        return {
+            neg: () => {
+                if (f.neg(0n) !== 0n) {
+                    throw '-0';
+                }
+                if (f.neg(1n) !== p - 1n) {
+                    throw '-1';
+                }
+            },
+            sub: () => {
+                if (f.sub(10n)(4n) !== 6n) {
+                    throw '10 - 4';
+                }
+                if (f.sub(11n)(14n) !== p - 3n) {
+                    throw '11 - 14';
+                }
+            },
+            add: () => {
+                if (f.add(13n)(24n) !== 37n) {
+                    throw '13 + 24';
+                }
+                if (f.add(77n)(f.neg(12n)) !== 65n) {
+                    throw '77 + (-12)';
+                }
+            },
+            mul: () => {
+                if (f.mul(100n)(0n) !== 0n) {
+                    throw '100 * 0';
+                }
+                if (f.mul(101n)(205n) !== 20705n) {
+                    throw '101 * 205';
+                }
+                if (f.mul(304n)(f.neg(1n)) !== f.neg(304n)) {
+                    throw '304 * -1';
+                }
+                if (f.mul(f.neg(507n))(609n) !== f.neg(308763n)) {
+                    throw '-507 * 609';
+                }
+                if (f.mul(f.neg(713n))(f.neg(825n)) !== 588225n) {
+                    throw '-713 * -825';
+                }
+            },
+            reciprocal: () => {
+                let i = 1n;
+                while (i < 10000n) {
+                    const x = f.reciprocal(i);
+                    if (f.mul(x)(i) !== 1n) {
+                        throw i;
+                    }
+                    ++i;
+                }
+            },
+            pow: () => {
+                /** @type {(a: bigint) => void} */
+                const test = a => {
+                    if (f.pow(a)(0n) !== 1n) {
+                        throw '**0';
+                    }
+                    if (f.pow(a)(1n) !== a) {
+                        throw '**1';
+                    }
+                    // https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
+                    // a^(p-1) % p = 1
+                    if (f.abs(f.pow(a)(f.middle)) !== 1n) {
+                        throw '**middle';
+                    }
+                    if (f.pow(a)(f.sub(f.max)(1n)) !== f.reciprocal(a)) {
+                        throw '**(max-1)';
+                    }
+                    if (f.pow(a)(f.max) !== 1n) {
+                        throw '**max';
+                    }
+                };
+                // 0
+                if (f.pow(0n)(0n) !== 1n) {
+                    throw '0**0';
+                }
+                if (f.pow(0n)(f.max) !== 0n) {
+                    throw '0**max';
+                }
+                // 1
+                test(1n);
+                // 2
+                test(2n);
+                if (f.pow(2n)(2n) !== 4n) {
+                    throw '2**2';
+                }
+                if (f.pow(2n)(3n) !== 8n) {
+                    throw '2**3';
+                }
+                if (f.pow(2n)(128n) !== 1n << 128n) {
+                    throw '2**128';
+                }
+                // 3
+                test(3n);
+                if (f.pow(3n)(2n) !== 9n) {
+                    throw '3**2';
+                }
+                if (f.pow(3n)(3n) !== 27n) {
+                    throw '3**3';
+                }
+                if (f.pow(3n)(100n) !== 3n ** 100n) {
+                    throw '3**100';
+                }
+                if (f.pow(3n)(110n) !== 3n ** 110n) {
+                    throw '3**110';
+                }
+                if (f.pow(3n)(120n) !== 3n ** 120n) {
+                    throw '3**120';
+                }
+                if (f.pow(3n)(121n) !== 3n ** 121n) {
+                    throw '3**121';
+                }
+                //
+                test(f.middle);
+                test(f.max - 1n);
+                test(f.max);
+            },
+            sqrt: () => {
+                /** @type {(a: bigint) => void} */
+                const test = a => {
+                    const a2 = f.mul(a)(a);
+                    const s = sqrt_f(a2);
+                    if (s !== null && f.abs(s) !== f.abs(a)) {
+                        throw 'sqrt';
+                    }
+                };
+                let i = 1n;
+                while (i < 1000n) {
+                    test(i);
+                    ++i;
+                }
+                test(f.middle);
+                test(f.max);
+            }
+        };
+    }
+};

package/out/secp/module.f.mjs

@@ -0,0 +1,113 @@
+// @ts-self-types="./module.f.d.mts"
+import * as Operator from '../types/function/operator/module.f.mjs';
+import * as pf from '../prime_field/module.f.mjs';
+import * as bi from '../types/bigint/module.f.mjs';
+const { scalar_mul } = bi;
+const { prime_field, sqrt } = pf;
+/** @typedef {readonly[bigint, bigint]} Point2D */
+/** @typedef {Point2D|null} Point */
+/**
+ * @typedef {{
+ *  readonly p: bigint
+ *  readonly a: readonly[bigint, bigint]
+ *  readonly g: readonly[bigint, bigint]
+ *  readonly n: bigint
+ * }} Init
+ */
+/**
+ * @typedef {{
+ *  readonly pf: pf.PrimeField
+ *  readonly nf: pf.PrimeField
+ *  readonly y2: (x: bigint) => bigint
+ *  readonly y: (x: bigint) => bigint|null
+ *  readonly neg: (a: Point) => Point
+ *  readonly add: Operator.Reduce<Point>
+ *  readonly mul: (a: Point) => (n: bigint) => Point
+ * }} Curve
+ */
+/** @type {(i: Init) => Curve} */
+export const curve = ({ p, a: [a0, a1], n }) => {
+    const pf = prime_field(p);
+    const { pow2, pow3, sub, add, mul, neg, div } = pf;
+    const mul3 = mul(3n);
+    const mul2 = mul(2n);
+    const addA1 = add(a1);
+    const mulA1 = mul(a1);
+    const addA0 = add(a0);
+    // y**2 = a1*x**3 + a0
+    /** @type {(x: bigint) => bigint} */
+    const y2 = x => addA0(add(pow3(x))(mulA1(x)));
+    /** @type {Operator.Reduce<Point>} */
+    const addPoint = p => q => {
+        if (p === null) {
+            return q;
+        }
+        if (q === null) {
+            return p;
+        }
+        const [px, py] = p;
+        const [qx, qy] = q;
+        const md = px === qx
+            // (3 * px ** 2 + a1) / (2 * py)
+            ? py !== qy || py === 0n ? null : [addA1(mul3(pow2(px))), mul2(py)]
+            // (py - qy) / (px - qx)
+            : [sub(py)(qy), sub(px)(qx)];
+        if (md === null) {
+            return null;
+        }
+        const [ma, mb] = md;
+        const m = div(ma)(mb);
+        // m ** 2 - px - qx
+        const rx = sub(pow2(m))(add(px)(qx));
+        // [rx, m * (px - rx) - py]
+        return [rx, sub(mul(m)(sub(px)(rx)))(py)];
+    };
+    const sqrt_p = sqrt(pf);
+    return {
+        pf,
+        nf: prime_field(n),
+        y2,
+        y: x => sqrt_p(y2(x)),
+        neg: p => {
+            if (p === null) {
+                return null;
+            }
+            const [x, y] = p;
+            return [x, neg(y)];
+        },
+        add: addPoint,
+        mul: scalar_mul({ 0: null, add: addPoint })
+    };
+};
+/** @type {(a: Point) => (b: Point) => boolean} */
+export const eq = a => b => {
+    if (a === null || b === null) {
+        return a === b;
+    }
+    const [ax, ay] = a;
+    const [bx, by] = b;
+    return ax === bx && ay === by;
+};
+/** @type {Init} */
+export const secp256k1 = {
+    p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
+    a: [7n, 0n],
+    g: [
+        0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
+        0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n
+    ],
+    n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
+};
+/** @type {Init} */
+export const secp192r1 = {
+    p: 0xfffffffffffffffffffffffffffffffeffffffffffffffffn,
+    a: [
+        0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1n,
+        0xfffffffffffffffffffffffffffffffefffffffffffffffcn
+    ],
+    g: [
+        0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012n,
+        0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811n
+    ],
+    n: 0xffffffffffffffffffffffff99def836146bc9b1b4d22831n,
+};

package/out/secp/test.f.mjs

@@ -0,0 +1,63 @@
+import * as _ from './module.f.mjs';
+const { curve, secp256k1, secp192r1, eq } = _;
+export default {
+    test: () => {
+        /** @type {(c: _.Init) => void} */
+        const test_curve = c => {
+            const { g } = c;
+            const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c);
+            /** @type {(p: _.Point) => void} */
+            const point_check = p => {
+                if (p === null) {
+                    throw 'null';
+                }
+                const [x, y] = p;
+                const ye = yf(x);
+                if (ye === null) {
+                    throw 'null';
+                }
+                if (abs(ye) !== abs(y)) {
+                    throw 'ye';
+                }
+            };
+            point_check(g);
+            point_check(neg(g));
+            /** @type {(p: _.Point) => void} */
+            const test_mul = p => {
+                if (mul(p)(0n) !== null) {
+                    throw 'O';
+                }
+                if (mul(p)(1n) !== p) {
+                    throw 'p';
+                }
+                if (mul(p)(n) !== null) {
+                    throw 'n';
+                }
+                const pn = neg(p);
+                if (!eq(mul(p)(n - 1n))(pn)) {
+                    throw 'n - 1';
+                }
+                /** @type {(s: bigint) => void} */
+                const f = s => {
+                    const r = mul(p)(s);
+                    point_check(r);
+                    const rn = mul(pn)(s);
+                    point_check(rn);
+                    if (!eq(r)(neg(rn))) {
+                        throw 'r != -rn';
+                    }
+                };
+                f(2n);
+                f(3n);
+                f(4n << 128n);
+                f((5n << 128n) + 6n);
+                f(7n << 128n);
+                f((8n << 128n) + 9n);
+            };
+            test_mul(g);
+            test_mul(neg(g));
+        };
+        test_curve(secp256k1);
+        test_curve(secp192r1);
+    }
+};

package/out/sha2/module.f.mjs

@@ -0,0 +1,172 @@
+// @ts-self-types="./module.f.d.mts"
+import * as arrayT from '../types/array/module.f.mjs';
+/**
+ * @typedef {{
+ *  readonly f: (i: number) => number
+ *  readonly length: number
+ * }} HashInput
+ */
+/** @typedef {arrayT.Array8<number>} Hash8 */
+/** @typedef {arrayT.Array16<number>} Array16 */
+/** @type {(input: number) => (pos: number) => number} */
+const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos);
+/** @type {(input: number) => (pos: number) => number} */
+const mod = a => b => (a % b + b) % b;
+/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
+export const padding = input => bitsCount => {
+    const appendBlockIndex = (bitsCount / 32) | 0;
+    const length = (bitsCount + mod(447 - bitsCount)(512) + 65) / 32;
+    /** @type {(i: number) => number} */
+    const f = i => {
+        if (i < appendBlockIndex) {
+            return input[i];
+        }
+        if (i === appendBlockIndex) {
+            return appendBlockIndex >= input.length ? 0x8000_0000 : appendOneWithZeros(input[appendBlockIndex])(31 - bitsCount % 32);
+        }
+        if (i === length - 2) {
+            return (bitsCount / 0x1_0000_0000) | 0;
+        }
+        if (i === length - 1) {
+            return bitsCount % 0x1_0000_0000;
+        }
+        return 0;
+    };
+    return ({ f, length });
+};
+/** @type {(d: number) => (n: number) => number} */
+const rotr = d => {
+    const r = 32 - d;
+    return n => n >>> d | n << r;
+};
+/** @type {(x: number) => (y: number) => (z: number) => number} */
+const ch = x => y => z => x & y ^ ~x & z;
+/** @type {(x: number) => (y: number) => (z: number) => number} */
+const maj = x => y => z => x & y ^ x & z ^ y & z;
+/** @type {(d: number) => (n: number) => number} */
+const shr = d => n => n >>> d;
+/** @type {(a: number) => (b: number) => (c: number) => (x: number) => number} */
+const bigSigma = a => b => c => {
+    const ra = rotr(a);
+    const rb = rotr(b);
+    const rc = rotr(c);
+    return x => ra(x) ^ rb(x) ^ rc(x);
+};
+const bigSigma0 = bigSigma(2)(13)(22);
+const bigSigma1 = bigSigma(6)(11)(25);
+/** @type {(a: number) => (b: number) => (c: number) => (x: number) => number} */
+const smallSigma = a => b => c => {
+    const ra = rotr(a);
+    const rb = rotr(b);
+    const sc = shr(c);
+    return x => ra(x) ^ rb(x) ^ sc(x);
+};
+const smallSigma0 = smallSigma(7)(18)(3);
+const smallSigma1 = smallSigma(17)(19)(10);
+/** @type {(a: arrayT.Array4<number>) => number} */
+const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) | 0;
+/** @type {(w: Array16) => Array16} */
+const nextW = ([w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF]) => {
+    w0 = wi([wE, w9, w1, w0]);
+    w1 = wi([wF, wA, w2, w1]);
+    w2 = wi([w0, wB, w3, w2]);
+    w3 = wi([w1, wC, w4, w3]);
+    w4 = wi([w2, wD, w5, w4]);
+    w5 = wi([w3, wE, w6, w5]);
+    w6 = wi([w4, wF, w7, w6]);
+    w7 = wi([w5, w0, w8, w7]);
+    w8 = wi([w6, w1, w9, w8]);
+    w9 = wi([w7, w2, wA, w9]);
+    wA = wi([w8, w3, wB, wA]);
+    wB = wi([w9, w4, wC, wB]);
+    wC = wi([wA, w5, wD, wC]);
+    wD = wi([wB, w6, wE, wD]);
+    wE = wi([wC, w7, wF, wE]);
+    wF = wi([wD, w8, w0, wF]);
+    return [w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF];
+};
+const k = [
+    [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    ],
+    [
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    ],
+    [
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    ],
+    [
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ],
+];
+/** @type {(init: Hash8) => (data: Array16) => Hash8} */
+const compress = ([a0, b0, c0, d0, e0, f0, g0, h0]) => data => {
+    let w = data;
+    let a = a0;
+    let b = b0;
+    let c = c0;
+    let d = d0;
+    let e = e0;
+    let f = f0;
+    let g = g0;
+    let h = h0;
+    let i = 0;
+    while (true) {
+        const ki = k[i];
+        for (let j = 0; j < 16; ++j) {
+            const t1 = h + bigSigma1(e) + ch(e)(f)(g) + ki[j] + w[j];
+            const t2 = bigSigma0(a) + maj(a)(b)(c);
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        if (i === 3) {
+            break;
+        }
+        ++i;
+        w = nextW(w);
+    }
+    return [
+        (a0 + a) | 0,
+        (b0 + b) | 0,
+        (c0 + c) | 0,
+        (d0 + d) | 0,
+        (e0 + e) | 0,
+        (f0 + f) | 0,
+        (g0 + g) | 0,
+        (h0 + h) | 0,
+    ];
+};
+/** @type {(init: Hash8) => (input: readonly number[]) => (bitsCount: number) => Hash8} */
+const compute = init => input => bitsCount => {
+    const { f, length } = padding(input)(bitsCount);
+    let result = init;
+    const chunkCount = length / 16;
+    for (let i = 0; i < chunkCount; i++) {
+        const s = i * 16;
+        result = compress(result)([
+            f(s + 0), f(s + 1), f(s + 2), f(s + 3), f(s + 4), f(s + 5), f(s + 6), f(s + 7),
+            f(s + 8), f(s + 9), f(s + 10), f(s + 11), f(s + 12), f(s + 13), f(s + 14), f(s + 15)
+        ]);
+    }
+    return result;
+};
+/** @type {Hash8} */
+const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+export const computeSha256 = compute(init256);
+/** @type {Hash8} */
+const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+export const computeSha224 = compute(init224);
+export const compress256 = compress(init256);
+export const compress224 = compress(init224);

package/out/sha2/test.f.mjs

@@ -0,0 +1,86 @@
+import * as _ from './module.f.mjs';
+import * as json from '../json/module.f.mjs';
+import * as o from '../types/object/module.f.mjs';
+const { sort } = o;
+/** @type {(a: number) => number} */
+const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000;
+/** @type {(a: number) => string} */
+const toHexString = x => toU32(x).toString(16).padStart(8, '0');
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a);
+// {
+//     const result = _.padding([])(0)
+//     console.log(result.map(toHexString))
+// }
+// {
+//     const result = _.padding([0x61626364, 0x65000000])(40)
+//     console.log(result.map(toHexString))
+// }
+// {
+//     const result = _.padding([0x11111110])(31)
+//     console.log(result.map(toHexString))
+// }
+// {
+//     const result = _.padding([0x11111110])(32)
+//     console.log(result.map(toHexString))
+// }
+export default {
+    empty: {
+        sha256: () => {
+            const hash = _.computeSha256([])(0);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["e3b0c442","98fc1c14","9afbf4c8","996fb924","27ae41e4","649b934c","a495991b","7852b855"]') {
+                throw result;
+            }
+        },
+        sha224: () => {
+            const hash = _.computeSha224([])(0);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["d14a028c","2a3a2bc9","476102bb","288234c4","15a2b01f","828ea62a","c5b3e42f","bdd387cb"]') {
+                throw result;
+            }
+        }
+    },
+    sha224compress: [
+        () => {
+            const hash = _.compress224([0x8000_0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["d14a028c","2a3a2bc9","476102bb","288234c4","15a2b01f","828ea62a","c5b3e42f","bdd387cb"]') {
+                throw result;
+            }
+        }
+    ],
+    sha256: [
+        () => {
+            //[0x68656C6C, 0x6F20776F, 0x726C6400] represents phrase 'hello world'
+            const hash = _.computeSha256([0x68656C6C, 0x6F20776F, 0x726C6400])(88);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["b94d27b9","934d3e08","a52e52d7","da7dabfa","c484efe3","7a5380ee","9088f7ac","e2efcde9"]') {
+                throw result;
+            }
+        },
+        () => {
+            //[0x68656C6C, 0x6F20776F, 0x726C6488] represents phrase 'hello world' with 1's at the end
+            const hash = _.computeSha256([0x68656C6C, 0x6F20776F, 0x726C64FF])(88);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["b94d27b9","934d3e08","a52e52d7","da7dabfa","c484efe3","7a5380ee","9088f7ac","e2efcde9"]') {
+                throw result;
+            }
+        },
+        () => {
+            const input = Array(8).fill(0x31313131);
+            const result = _.computeSha256(input)(256);
+            if (toU32(result[0]) !== 0x8a83665f) {
+                throw result[0];
+            }
+        },
+        () => {
+            const input = Array(16).fill(0x31313131);
+            const hash = _.computeSha256(input)(512);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["3138bb9b","c78df27c","473ecfd1","410f7bd4","5ebac1f5","9cf3ff9c","fe4db77a","ab7aedd3"]') {
+                throw result;
+            }
+        }
+    ]
+};