openttt 0.2.4 → 0.2.5

package/dist/golay.d.ts

@@ -0,0 +1,7 @@
+export interface GolayDecodeResult {
+    data: Uint8Array;
+    corrected: number;
+    uncorrectable: boolean;
+}
+export declare function golayEncode(data: Uint8Array): Uint8Array;
+export declare function golayDecode(encoded: Uint8Array): GolayDecodeResult;

package/dist/golay.js

@@ -0,0 +1,139 @@
+"use strict";
+// sdk/src/golay.ts
+// Golay(24,12) Extended Binary Golay Code
+// Corrects up to 3 bit errors, detects 4 bit errors.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.golayEncode = golayEncode;
+exports.golayDecode = golayDecode;
+// Standard Golay Parity Matrix P (12x12) - Systematic Form [I12 | P]
+// Every row has weight 7.
+// Verified: P*P^T = I (mod 2), all rows weight 7.
+const P = [
+    0xC75, 0x49F, 0xD4B, 0x6E3, 0x9B3, 0xB66,
+    0xECC, 0x1ED, 0x3DA, 0x7B4, 0xB1D, 0xE3A
+];
+// P^T (transpose of P) — required for second syndrome computation.
+// P is NOT symmetric, so s2 = s*P^T must use this separate matrix.
+const PT = [
+    0xAE3, 0xF25, 0x16F, 0x2DE, 0x5BC, 0xB78,
+    0x9D5, 0xC8F, 0x63B, 0xC76, 0x7C9, 0xF92
+];
+const UNIT_VECTORS = [
+    0x800, 0x400, 0x200, 0x100, 0x080, 0x040,
+    0x020, 0x010, 0x008, 0x004, 0x002, 0x001
+];
+function weight(n) {
+    let count = 0;
+    let temp = n & 0xFFF;
+    while (temp > 0) {
+        temp &= (temp - 1);
+        count++;
+    }
+    return count;
+}
+function multiplyP(v) {
+    let res = 0;
+    for (let i = 0; i < 12; i++) {
+        if ((v >> (11 - i)) & 1) {
+            res ^= P[i];
+        }
+    }
+    return res & 0xFFF;
+}
+function multiplyPT(v) {
+    let res = 0;
+    for (let i = 0; i < 12; i++) {
+        if ((v >> (11 - i)) & 1) {
+            res ^= PT[i];
+        }
+    }
+    return res & 0xFFF;
+}
+function encodeWord(msg) {
+    const parity = multiplyP(msg & 0xFFF);
+    return ((msg & 0xFFF) << 12) | parity;
+}
+function decodeWord(received) {
+    let r_m = (received >> 12) & 0xFFF;
+    const r_p = received & 0xFFF;
+    const s = multiplyP(r_m) ^ r_p;
+    if (s === 0)
+        return { msg: r_m, corrected: 0, uncorrectable: false };
+    if (weight(s) <= 3) {
+        return { msg: r_m, corrected: weight(s), uncorrectable: false };
+    }
+    for (let i = 0; i < 12; i++) {
+        if (weight(s ^ P[i]) <= 2) {
+            return { msg: r_m ^ UNIT_VECTORS[i], corrected: weight(s ^ P[i]) + 1, uncorrectable: false };
+        }
+    }
+    const s2 = multiplyPT(s);
+    if (weight(s2) <= 3) {
+        return { msg: r_m ^ s2, corrected: weight(s2), uncorrectable: false };
+    }
+    for (let i = 0; i < 12; i++) {
+        if (weight(s2 ^ PT[i]) <= 2) {
+            const error_m = s2 ^ PT[i];
+            return { msg: r_m ^ error_m, corrected: weight(s2 ^ PT[i]) + 1, uncorrectable: false };
+        }
+    }
+    return { msg: r_m, corrected: 0, uncorrectable: true };
+}
+function golayEncode(data) {
+    const out = new Uint8Array(Math.ceil(data.length / 3) * 6);
+    let outIdx = 0;
+    for (let i = 0; i < data.length; i += 3) {
+        const b1 = data[i];
+        const b2 = i + 1 < data.length ? data[i + 1] : 0;
+        const b3 = i + 2 < data.length ? data[i + 2] : 0;
+        const w1 = (b1 << 4) | (b2 >> 4);
+        const c1 = encodeWord(w1);
+        out[outIdx++] = (c1 >> 16) & 0xFF;
+        out[outIdx++] = (c1 >> 8) & 0xFF;
+        out[outIdx++] = c1 & 0xFF;
+        if (i + 1 < data.length) {
+            const w2 = ((b2 & 0x0F) << 8) | b3;
+            const c2 = encodeWord(w2);
+            out[outIdx++] = (c2 >> 16) & 0xFF;
+            out[outIdx++] = (c2 >> 8) & 0xFF;
+            out[outIdx++] = c2 & 0xFF;
+        }
+    }
+    return out;
+}
+function golayDecode(encoded) {
+    if (encoded.length % 6 !== 0) {
+        throw new Error("Invalid Golay encoded data: length must be multiple of 6");
+    }
+    const outLen = Math.floor(encoded.length / 2);
+    const out = new Uint8Array(outLen);
+    let outIdx = 0;
+    let totalCorrected = 0;
+    let anyUncorrectable = false;
+    for (let i = 0; i < encoded.length; i += 6) {
+        const c1 = (encoded[i] << 16) | (encoded[i + 1] << 8) | encoded[i + 2];
+        const res1 = decodeWord(c1);
+        totalCorrected += res1.corrected;
+        if (res1.uncorrectable)
+            anyUncorrectable = true;
+        if (outIdx < outLen)
+            out[outIdx++] = (res1.msg >> 4) & 0xFF;
+        const b2_high = (res1.msg & 0x0F) << 4;
+        if (i + 3 < encoded.length) {
+            const c2 = (encoded[i + 3] << 16) | (encoded[i + 4] << 8) | encoded[i + 5];
+            const res2 = decodeWord(c2);
+            totalCorrected += res2.corrected;
+            if (res2.uncorrectable)
+                anyUncorrectable = true;
+            if (outIdx < outLen)
+                out[outIdx++] = b2_high | (res2.msg >> 8);
+            if (outIdx < outLen)
+                out[outIdx++] = res2.msg & 0xFF;
+        }
+        else {
+            if (outIdx < outLen)
+                out[outIdx++] = b2_high;
+        }
+    }
+    return { data: out, corrected: totalCorrected, uncorrectable: anyUncorrectable };
+}

package/dist/grg_forward.d.ts

@@ -0,0 +1,7 @@
+export declare class GrgForward {
+    static golombEncode(data: Uint8Array, m?: number): Uint8Array;
+    static redstuffEncode(data: Uint8Array, shards?: number, parity?: number): Uint8Array[];
+    static deriveHmacKey(chainId: number, poolAddress: string): Buffer;
+    static golayEncodeWrapper(data: Uint8Array, hmacKey: Buffer): Uint8Array;
+    static encode(data: Uint8Array, chainId: number, poolAddress: string): Uint8Array[];
+}

package/dist/grg_forward.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrgForward = void 0;
+// sdk/src/grg_forward.ts
+const crypto_1 = require("crypto");
+const ethers_1 = require("ethers");
+const golay_1 = require("./golay");
+const reed_solomon_1 = require("./reed_solomon");
+class GrgForward {
+    static golombEncode(data, m = 16) {
+        if (m < 2)
+            throw new Error("[GRG] Golomb parameter m must be >= 2");
+        const k = Math.log2(m);
+        if (!Number.isInteger(k))
+            throw new Error("M must be power of 2");
+        const bits = [];
+        for (const byte of data) {
+            const q = Math.floor(byte / m);
+            const r = byte % m;
+            for (let i = 0; i < q; i++)
+                bits.push(1);
+            bits.push(0);
+            for (let i = k - 1; i >= 0; i--)
+                bits.push((r >> i) & 1);
+        }
+        const out = new Uint8Array(Math.ceil(bits.length / 8));
+        for (let i = 0; i < bits.length; i++) {
+            if (bits[i])
+                out[i >> 3] |= (0x80 >> (i & 7));
+        }
+        return out;
+    }
+    static redstuffEncode(data, shards = 4, parity = 2) {
+        return reed_solomon_1.ReedSolomon.encode(data, shards, parity);
+    }
+    static deriveHmacKey(chainId, poolAddress) {
+        if (chainId === undefined || chainId === null || !poolAddress) {
+            throw new Error("[GRG] chainId and poolAddress are required for HMAC key derivation. No default key is allowed.");
+        }
+        const packed = (0, ethers_1.keccak256)(ethers_1.AbiCoder.defaultAbiCoder().encode(["uint256", "address"], [chainId, poolAddress]));
+        return Buffer.from(packed.slice(2), "hex");
+    }
+    static golayEncodeWrapper(data, hmacKey) {
+        const encoded = (0, golay_1.golayEncode)(data);
+        const mac = (0, crypto_1.createHmac)("sha256", hmacKey).update(Buffer.from(encoded)).digest();
+        const checksum = mac.subarray(0, 8);
+        const final = new Uint8Array(encoded.length + 8);
+        final.set(encoded);
+        final.set(checksum, encoded.length);
+        return final;
+    }
+    static encode(data, chainId, poolAddress) {
+        if (data.length === 0) {
+            throw new Error("[GRG] Cannot encode empty input — roundtrip identity violation");
+        }
+        const compressed = this.golombEncode(data);
+        const withLen = new Uint8Array(4 + compressed.length);
+        withLen[0] = (data.length >> 24) & 0xFF;
+        withLen[1] = (data.length >> 16) & 0xFF;
+        withLen[2] = (data.length >> 8) & 0xFF;
+        withLen[3] = data.length & 0xFF;
+        withLen.set(compressed, 4);
+        const shards = this.redstuffEncode(withLen);
+        const hmacKey = this.deriveHmacKey(chainId, poolAddress);
+        return shards.map(s => this.golayEncodeWrapper(s, hmacKey));
+    }
+}
+exports.GrgForward = GrgForward;

package/dist/grg_inverse.d.ts

@@ -0,0 +1,7 @@
+export declare class GrgInverse {
+    private static readonly MAX_GOLOMB_Q;
+    static golayDecodeWrapper(data: Uint8Array, hmacKey: Buffer): Uint8Array;
+    static redstuffDecode(shards: (Uint8Array | null)[], dataShardCount?: number, parityShardCount?: number): Uint8Array;
+    static golombDecode(data: Uint8Array, m?: number, originalLength?: number): Uint8Array;
+    static verify(data: Uint8Array, originalShards: Uint8Array[], chainId: number, poolAddress: string): boolean;
+}

package/dist/grg_inverse.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrgInverse = void 0;
+// sdk/src/grg_inverse.ts
+const crypto_1 = require("crypto");
+const golay_1 = require("./golay");
+const grg_forward_1 = require("./grg_forward");
+const logger_1 = require("./logger");
+const reed_solomon_1 = require("./reed_solomon");
+class GrgInverse {
+    static MAX_GOLOMB_Q = 1000000;
+    static golayDecodeWrapper(data, hmacKey) {
+        if (data.length < 8)
+            throw new Error("GRG shard too short for checksum");
+        const encoded = data.subarray(0, data.length - 8);
+        const checksum = data.subarray(data.length - 8);
+        const mac = (0, crypto_1.createHmac)("sha256", hmacKey).update(Buffer.from(encoded)).digest();
+        const expected = mac.subarray(0, 8);
+        if (!Buffer.from(checksum).equals(Buffer.from(expected))) {
+            throw new Error("GRG tamper detected: HMAC-SHA256 checksum mismatch");
+        }
+        const res = (0, golay_1.golayDecode)(encoded);
+        if (res.uncorrectable) {
+            throw new Error("GRG tamper detected: uncorrectable bit errors in Golay codeword");
+        }
+        return res.data;
+    }
+    static redstuffDecode(shards, dataShardCount = 4, parityShardCount = 2) {
+        return reed_solomon_1.ReedSolomon.decode(shards, dataShardCount, parityShardCount);
+    }
+    static golombDecode(data, m = 16, originalLength) {
+        if (m < 2)
+            throw new Error("[GRG] Golomb parameter m must be >= 2");
+        const k = Math.log2(m);
+        const totalBits = data.length * 8;
+        const readBit = (pos) => (data[pos >> 3] >> (7 - (pos & 7))) & 1;
+        const result = [];
+        let i = 0;
+        while (i < totalBits) {
+            if (originalLength !== undefined && result.length >= originalLength)
+                break;
+            let q = 0;
+            while (i < totalBits && readBit(i) === 1) {
+                q++;
+                i++;
+                if (q > this.MAX_GOLOMB_Q)
+                    throw new Error(`[GRG] Golomb decode: unary run exceeds ${this.MAX_GOLOMB_Q} — malformed or malicious input`);
+            }
+            if (i < totalBits && readBit(i) === 0)
+                i++;
+            if (i + k > totalBits)
+                break;
+            let r = 0;
+            for (let j = 0; j < k; j++)
+                r = (r << 1) | readBit(i + j);
+            result.push(q * m + r);
+            i += k;
+        }
+        return new Uint8Array(result);
+    }
+    static verify(data, originalShards, chainId, poolAddress) {
+        try {
+            const hmacKey = grg_forward_1.GrgForward.deriveHmacKey(chainId, poolAddress);
+            const decodedShards = originalShards.map(s => {
+                try {
+                    return this.golayDecodeWrapper(s, hmacKey);
+                }
+                catch {
+                    return null;
+                }
+            });
+            const withLen = this.redstuffDecode(decodedShards);
+            if (withLen.length < 4)
+                return false;
+            const origLen = (withLen[0] << 24) | (withLen[1] << 16) | (withLen[2] << 8) | withLen[3];
+            const compressed = withLen.subarray(4);
+            const decoded = this.golombDecode(compressed);
+            const final = decoded.subarray(0, origLen);
+            if (final.length !== data.length)
+                return false;
+            for (let i = 0; i < data.length; i++) {
+                if (final[i] !== data[i])
+                    return false;
+            }
+            return true;
+        }
+        catch (e) {
+            logger_1.logger.warn(`[GRG Inverse] Verification failed: ${e}`);
+            return false;
+        }
+    }
+}
+exports.GrgInverse = GrgInverse;

package/dist/grg_pipeline.d.ts

@@ -0,0 +1,5 @@
+export declare class GrgPipeline {
+    private static readonly MAX_INPUT_SIZE;
+    static processForward(data: Uint8Array, chainId: number, poolAddress: string): Uint8Array[];
+    static processInverse(shards: (Uint8Array | null)[], originalLength: number, chainId: number, poolAddress: string): Uint8Array;
+}

package/dist/grg_pipeline.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrgPipeline = void 0;
+// sdk/src/grg_pipeline.ts
+const grg_forward_1 = require("./grg_forward");
+const grg_inverse_1 = require("./grg_inverse");
+const logger_1 = require("./logger");
+class GrgPipeline {
+    static MAX_INPUT_SIZE = 100 * 1024 * 1024; // 100 MB
+    static processForward(data, chainId, poolAddress) {
+        if (data.length > this.MAX_INPUT_SIZE) {
+            throw new Error(`[GRG] Input size ${data.length} exceeds MAX_INPUT_SIZE ${this.MAX_INPUT_SIZE}`);
+        }
+        logger_1.logger.info("Starting GRG forward pipeline...");
+        try {
+            const shards = grg_forward_1.GrgForward.encode(data, chainId, poolAddress);
+            logger_1.logger.info(`GRG forward pipeline complete. Generated ${shards.length} shards.`);
+            return shards;
+        }
+        catch (error) {
+            logger_1.logger.error(`GRG forward pipeline failed: ${error}`);
+            throw error;
+        }
+    }
+    static processInverse(shards, originalLength, chainId, poolAddress) {
+        logger_1.logger.info("Starting GRG inverse pipeline...");
+        try {
+            const hmacKey = grg_forward_1.GrgForward.deriveHmacKey(chainId, poolAddress);
+            const decodedShards = shards.map(s => {
+                try {
+                    return s ? grg_inverse_1.GrgInverse.golayDecodeWrapper(s, hmacKey) : null;
+                }
+                catch (e) {
+                    logger_1.logger.warn(`Golay decode failed for a shard: ${e}`);
+                    return null;
+                }
+            });
+            const withLen = grg_inverse_1.GrgInverse.redstuffDecode(decodedShards);
+            const decodedLength = (withLen[0] << 24) | (withLen[1] << 16) | (withLen[2] << 8) | withLen[3];
+            const compressed = withLen.subarray(4);
+            const decompressed = grg_inverse_1.GrgInverse.golombDecode(compressed);
+            const final = decompressed.subarray(0, decodedLength);
+            if (final.length !== originalLength) {
+                throw new Error(`[GRG] Length mismatch in inverse: expected ${originalLength}, got ${final.length}`);
+            }
+            logger_1.logger.info("GRG inverse pipeline complete.");
+            return final;
+        }
+        catch (error) {
+            logger_1.logger.error(`GRG inverse pipeline failed: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.GrgPipeline = GrgPipeline;

package/dist/reed_solomon.d.ts

@@ -0,0 +1,13 @@
+export declare class ReedSolomon {
+    private static expTable;
+    private static logTable;
+    private static initialized;
+    private static vandermondeCache;
+    static init(): void;
+    static mul(a: number, b: number): number;
+    static div(a: number, b: number): number;
+    static invertMatrix(matrix: number[][]): number[][];
+    static buildVandermonde(rows: number, cols: number): number[][];
+    static encode(data: Uint8Array, dataShards?: number, parityShards?: number): Uint8Array[];
+    static decode(shards: (Uint8Array | null)[], dataShards?: number, parityShards?: number): Uint8Array;
+}

package/dist/reed_solomon.js

@@ -0,0 +1,170 @@
+"use strict";
+// sdk/src/reed_solomon.ts
+// Reed-Solomon GF(2^8) erasure coding
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReedSolomon = void 0;
+class ReedSolomon {
+    static expTable = new Uint8Array(256);
+    static logTable = new Uint8Array(256);
+    static initialized = false;
+    static vandermondeCache = new Map();
+    static init() {
+        if (this.initialized)
+            return;
+        let x = 1;
+        for (let i = 0; i < 255; i++) {
+            this.expTable[i] = x;
+            this.logTable[x] = i;
+            x <<= 1;
+            if (x & 0x100) {
+                x ^= 0x11D; // x^8 + x^4 + x^3 + x^2 + 1
+            }
+        }
+        this.expTable[255] = this.expTable[0];
+        this.logTable[0] = 0;
+        this.initialized = true;
+    }
+    static mul(a, b) {
+        if (a === 0 || b === 0)
+            return 0;
+        return this.expTable[(this.logTable[a] + this.logTable[b]) % 255];
+    }
+    static div(a, b) {
+        if (b === 0)
+            throw new Error("Division by zero");
+        if (a === 0)
+            return 0;
+        return this.expTable[(this.logTable[a] - this.logTable[b] + 255) % 255];
+    }
+    static invertMatrix(matrix) {
+        const n = matrix.length;
+        const aug = [];
+        for (let i = 0; i < n; i++) {
+            aug[i] = [];
+            for (let j = 0; j < n; j++)
+                aug[i][j] = matrix[i][j];
+            for (let j = 0; j < n; j++)
+                aug[i][j + n] = (i === j) ? 1 : 0;
+        }
+        for (let i = 0; i < n; i++) {
+            let pivot = i;
+            while (pivot < n && aug[pivot][i] === 0)
+                pivot++;
+            if (pivot === n)
+                throw new Error("Singular matrix");
+            if (pivot !== i) {
+                const temp = aug[i];
+                aug[i] = aug[pivot];
+                aug[pivot] = temp;
+            }
+            const pivotVal = aug[i][i];
+            if (pivotVal !== 1) {
+                for (let j = i; j < 2 * n; j++)
+                    aug[i][j] = this.div(aug[i][j], pivotVal);
+            }
+            for (let j = 0; j < n; j++) {
+                if (i !== j && aug[j][i] !== 0) {
+                    const factor = aug[j][i];
+                    for (let k = i; k < 2 * n; k++)
+                        aug[j][k] ^= this.mul(factor, aug[i][k]);
+                }
+            }
+        }
+        const inv = [];
+        for (let i = 0; i < n; i++) {
+            inv[i] = [];
+            for (let j = 0; j < n; j++)
+                inv[i][j] = aug[i][j + n];
+        }
+        return inv;
+    }
+    static buildVandermonde(rows, cols) {
+        const cacheKey = `${rows}-${cols}`;
+        const cached = this.vandermondeCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const V = [];
+        for (let r = 0; r < rows; r++) {
+            V[r] = [];
+            const x = r + 1;
+            for (let c = 0; c < cols; c++) {
+                V[r][c] = c === 0 ? 1 : this.mul(V[r][c - 1], x);
+            }
+        }
+        const V_top = [];
+        for (let i = 0; i < cols; i++)
+            V_top.push([...V[i]]);
+        const V_top_inv = this.invertMatrix(V_top);
+        const G = [];
+        for (let r = 0; r < rows; r++) {
+            G[r] = [];
+            for (let c = 0; c < cols; c++) {
+                let val = 0;
+                for (let k = 0; k < cols; k++)
+                    val ^= this.mul(V[r][k], V_top_inv[k][c]);
+                G[r][c] = val;
+            }
+        }
+        this.vandermondeCache.set(cacheKey, G);
+        return G;
+    }
+    static encode(data, dataShards = 4, parityShards = 2) {
+        this.init();
+        const totalShards = dataShards + parityShards;
+        const rawShardSize = Math.ceil(data.length / dataShards);
+        const shardSize = Math.ceil(rawShardSize / 3) * 3;
+        const matrix = this.buildVandermonde(totalShards, dataShards);
+        const shards = [];
+        for (let i = 0; i < totalShards; i++)
+            shards.push(new Uint8Array(shardSize));
+        for (let i = 0; i < dataShards; i++) {
+            shards[i].set(data.subarray(i * shardSize, Math.min((i + 1) * shardSize, data.length)));
+        }
+        for (let c = 0; c < shardSize; c++) {
+            for (let r = dataShards; r < totalShards; r++) {
+                let val = 0;
+                for (let j = 0; j < dataShards; j++)
+                    val ^= this.mul(matrix[r][j], shards[j][c]);
+                shards[r][c] = val;
+            }
+        }
+        return shards;
+    }
+    static decode(shards, dataShards = 4, parityShards = 2) {
+        this.init();
+        const totalShards = dataShards + parityShards;
+        if (shards.length !== totalShards) {
+            throw new Error(`[RS] Expected ${totalShards} shards, got ${shards.length}`);
+        }
+        const presentIndices = [];
+        const presentShards = [];
+        for (let i = 0; i < totalShards; i++) {
+            if (shards[i] !== null && shards[i] !== undefined) {
+                presentIndices.push(i);
+                presentShards.push(shards[i]);
+                if (presentIndices.length === dataShards)
+                    break;
+            }
+        }
+        if (presentIndices.length < dataShards) {
+            throw new Error(`[RS] Not enough shards for recovery: need ${dataShards}, got ${presentIndices.length}`);
+        }
+        const shardSize = presentShards[0].length;
+        const origMatrix = this.buildVandermonde(totalShards, dataShards);
+        const subMatrix = [];
+        for (let i = 0; i < dataShards; i++)
+            subMatrix.push([...origMatrix[presentIndices[i]]]);
+        const invMatrix = this.invertMatrix(subMatrix);
+        const result = new Uint8Array(shardSize * dataShards);
+        for (let c = 0; c < shardSize; c++) {
+            for (let r = 0; r < dataShards; r++) {
+                let val = 0;
+                for (let j = 0; j < dataShards; j++)
+                    val ^= this.mul(invMatrix[r][j], presentShards[j][c]);
+                result[r * shardSize + c] = val;
+            }
+        }
+        return result;
+    }
+}
+exports.ReedSolomon = ReedSolomon;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openttt",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "OpenTTT — TLS-grade transaction ordering for DeFi. Time + Logic + Sync.",
   "license": "BSL-1.1",
   "repository": {
@@ -31,11 +31,6 @@
   },
   "files": [
     "dist",
-    "!dist/golay.*",
-    "!dist/grg_forward.*",
-    "!dist/grg_inverse.*",
-    "!dist/grg_pipeline.*",
-    "!dist/reed_solomon.*",
     "README.md"
   ],
   "scripts": {