o1js-pack 0.4.1 → 0.4.3

package/build/src/lib/PackingPlant.js

@@ -1,191 +1,191 @@
-import { Field, Struct, provable, Provable, } from 'o1js';
-const MAX_BITS_PER_FIELD = 254n;
-export function PackingPlant(elementType, l, bitSize) {
-    if (bitSize * BigInt(l) > MAX_BITS_PER_FIELD) {
-        throw new Error(`The Packing Plant is only accepting orders that can fit into one Field, try using MultiPackingPlant`);
-    }
-    class Packed_ extends Struct({
-        packed: Field,
-    }) {
-        constructor(packed) {
-            super({ packed });
-        }
-        // Must implement these in type-specific implementation
-        static extractField(input) {
-            throw new Error('Must implement extractField');
-        }
-        static sizeInBits() {
-            throw new Error('Must implement sizeInBits');
-        }
-        static unpack(f) {
-            throw new Error('Must implement unpack');
-        }
-        // End
-        /**
-         *
-         * @param unpacked Array of the implemented packed type
-         * @throws if the length of the array is longer than the length of the implementing factory config
-         */
-        static checkPack(unpacked) {
-            if (unpacked.length > l) {
-                throw new Error(`Input of size ${unpacked.length} is larger than expected size of ${l}`);
-            }
-        }
-        /**
-         *
-         * @param unpacked Array of the implemented packed type, must be shorter than the max allowed, which varies by type, will throw if the input is too long
-         * @returns Field, packed with the information from the unpacked input
-         */
-        static pack(unpacked) {
-            this.checkPack(unpacked);
-            let f = this.extractField(unpacked[0]);
-            const n = Math.min(unpacked.length, l);
-            for (let i = 1; i < n; i++) {
-                const c = Field((2n ** this.sizeInBits()) ** BigInt(i));
-                f = f.add(this.extractField(unpacked[i]).mul(c));
-            }
-            return f;
-        }
-        /**
-         *
-         * @param f Field, packed with the information, as returned by #pack
-         * @returns Array of bigints, which can be decoded by the implementing class into the final type
-         */
-        static unpackToBigints(f) {
-            let unpacked = new Array(l);
-            unpacked.fill(0n);
-            let packedN;
-            if (f) {
-                packedN = f.toBigInt();
-            }
-            else {
-                throw new Error('No Packed Value Provided');
-            }
-            for (let i = 0; i < l; i++) {
-                unpacked[i] = packedN & ((1n << this.sizeInBits()) - 1n);
-                packedN >>= this.sizeInBits();
-            }
-            return unpacked;
-        }
-        assertEquals(other) {
-            this.packed.assertEquals(other.packed);
-        }
-    }
-    Packed_.type = provable({ packed: Field }, {});
-    Packed_.l = l;
-    Packed_.bitSize = bitSize;
-    return Packed_;
-}
-export function MultiPackingPlant(elementType, l, bitSize) {
-    if (bitSize * BigInt(l) > 8n * MAX_BITS_PER_FIELD) {
-        throw new Error(`The Packing Plant is only accepting orders that can fit into eight Fields`);
-    }
-    const n = Math.ceil(Number(bitSize * BigInt(l)) / Number(255n));
-    class Packed_ extends Struct({
-        packed: Provable.Array(Field, n),
-    }) {
-        constructor(packed) {
-            super({ packed });
-        }
-        // Must implement these in type-specific implementation
-        static extractField(input) {
-            throw new Error('Must implement extractField');
-        }
-        static sizeInBits() {
-            throw new Error('Must implement sizeInBits');
-        }
-        static elementsPerField() {
-            throw new Error('Must implement elementsPerField');
-        }
-        static unpack(fields) {
-            throw new Error('Must implement unpack');
-        }
-        // End
-        /**
-         *
-         * @param unpacked Array of the implemented packed type
-         * @throws if the length of the array is longer than the length of the implementing factory config
-         */
-        static checkPack(unpacked) {
-            if (unpacked.length > this.l) {
-                throw new Error(`Input of size ${unpacked.length} is larger than expected size of ${l}`);
-            }
-        }
-        /**
-         *
-         * @param unpacked Array of the implemented packed type, must be shorter than the max allowed, which varies by type, will throw if the input is too long
-         * @returns Array of Fields, packed such that each Field has as much information as possible
-         *
-         * e.g. 15 Characters pack into 1 Field.  15 or fewer Characters will return an array of 1 Field
-         *      30 of fewer Characters will return an aray of 2 Fields
-         */
-        static pack(unpacked) {
-            this.checkPack(unpacked);
-            const q = this.elementsPerField();
-            let fields = [];
-            let mutableUnpacked = [...unpacked];
-            for (let i = 0; i < this.n; i++) {
-                let f = this.extractField(mutableUnpacked[i * q]);
-                if (!f) {
-                    throw new Error('Unexpected Array Length');
-                }
-                for (let j = 1; j < q; j++) {
-                    const idx = i * q + j;
-                    let value = this.extractField(mutableUnpacked[idx]);
-                    if (!value) {
-                        throw new Error('Unexpected Array Length');
-                    }
-                    value = value || Field(0);
-                    const c = Field((2n ** this.sizeInBits()) ** BigInt(j));
-                    f = f.add(value.mul(c));
-                }
-                fields.push(f);
-            }
-            return fields;
-        }
-        /**
-         *
-         * @param fields Array of Fields, packed such that each Field has as much information as possible, as returned in #pack
-         * @returns Array of bigints, which can be decoded by the implementing class into the final type
-         */
-        static unpackToBigints(fields) {
-            let uints_ = new Array(this.l); // array length is number of elements per field * number of fields
-            uints_.fill(0n);
-            let packedNs = new Array(this.n);
-            packedNs.fill(0n);
-            const packedArg = new Array(this.n);
-            packedArg.fill(Field(0), 0, this.n);
-            for (let i = 0; i < this.n; i++) {
-                if (fields[i]) {
-                    packedArg[i] = fields[i];
-                }
-            }
-            if (packedArg.length !== this.n) {
-                throw new Error(`Packed value must be exactly ${this.n} in length`);
-            }
-            for (let i = 0; i < this.n; i++) {
-                packedNs[i] = packedArg[i].toConstant().toBigInt();
-            }
-            for (let i = 0; i < packedNs.length; i++) {
-                let packedN = packedNs[i];
-                for (let j = 0; j < this.elementsPerField(); j++) {
-                    const k = i * this.elementsPerField() + j;
-                    uints_[k] = packedN & ((1n << this.sizeInBits()) - 1n);
-                    packedN >>= this.sizeInBits();
-                }
-            }
-            return uints_;
-        }
-        assertEquals(other) {
-            for (let x = 0; x < n; x++) {
-                this.packed[x].assertEquals(other.packed[x]);
-            }
-        }
-    }
-    Packed_.type = provable({ packed: Provable.Array(Field, n) }, {});
-    Packed_.l = l;
-    Packed_.n = n;
-    Packed_.bitSize = bitSize;
-    return Packed_;
-}
+import { Field, Struct, provable, Provable, } from 'o1js';
+const MAX_BITS_PER_FIELD = 254n;
+export function PackingPlant(elementType, l, bitSize) {
+    if (bitSize * BigInt(l) > MAX_BITS_PER_FIELD) {
+        throw new Error(`The Packing Plant is only accepting orders that can fit into one Field, try using MultiPackingPlant`);
+    }
+    class Packed_ extends Struct({
+        packed: Field,
+    }) {
+        constructor(packed) {
+            super({ packed });
+        }
+        // Must implement these in type-specific implementation
+        static extractField(input) {
+            throw new Error('Must implement extractField');
+        }
+        static sizeInBits() {
+            throw new Error('Must implement sizeInBits');
+        }
+        static unpack(f) {
+            throw new Error('Must implement unpack');
+        }
+        // End
+        /**
+         *
+         * @param unpacked Array of the implemented packed type
+         * @throws if the length of the array is longer than the length of the implementing factory config
+         */
+        static checkPack(unpacked) {
+            if (unpacked.length > l) {
+                throw new Error(`Input of size ${unpacked.length} is larger than expected size of ${l}`);
+            }
+        }
+        /**
+         *
+         * @param unpacked Array of the implemented packed type, must be shorter than the max allowed, which varies by type, will throw if the input is too long
+         * @returns Field, packed with the information from the unpacked input
+         */
+        static pack(unpacked) {
+            this.checkPack(unpacked);
+            let f = this.extractField(unpacked[0]);
+            const n = Math.min(unpacked.length, l);
+            for (let i = 1; i < n; i++) {
+                const c = Field((2n ** this.sizeInBits()) ** BigInt(i));
+                f = f.add(this.extractField(unpacked[i]).mul(c));
+            }
+            return f;
+        }
+        /**
+         *
+         * @param f Field, packed with the information, as returned by #pack
+         * @returns Array of bigints, which can be decoded by the implementing class into the final type
+         */
+        static unpackToBigints(f) {
+            let unpacked = new Array(l);
+            unpacked.fill(0n);
+            let packedN;
+            if (f) {
+                packedN = f.toBigInt();
+            }
+            else {
+                throw new Error('No Packed Value Provided');
+            }
+            for (let i = 0; i < l; i++) {
+                unpacked[i] = packedN & ((1n << this.sizeInBits()) - 1n);
+                packedN >>= this.sizeInBits();
+            }
+            return unpacked;
+        }
+        assertEquals(other) {
+            this.packed.assertEquals(other.packed);
+        }
+    }
+    Packed_.type = provable({ packed: Field }, {});
+    Packed_.l = l;
+    Packed_.bitSize = bitSize;
+    return Packed_;
+}
+export function MultiPackingPlant(elementType, l, bitSize) {
+    if (bitSize * BigInt(l) > 8n * MAX_BITS_PER_FIELD) {
+        throw new Error(`The Packing Plant is only accepting orders that can fit into eight Fields`);
+    }
+    const n = Math.ceil(Number(bitSize * BigInt(l)) / Number(255n));
+    class Packed_ extends Struct({
+        packed: Provable.Array(Field, n),
+    }) {
+        constructor(packed) {
+            super({ packed });
+        }
+        // Must implement these in type-specific implementation
+        static extractField(input) {
+            throw new Error('Must implement extractField');
+        }
+        static sizeInBits() {
+            throw new Error('Must implement sizeInBits');
+        }
+        static elementsPerField() {
+            throw new Error('Must implement elementsPerField');
+        }
+        static unpack(fields) {
+            throw new Error('Must implement unpack');
+        }
+        // End
+        /**
+         *
+         * @param unpacked Array of the implemented packed type
+         * @throws if the length of the array is longer than the length of the implementing factory config
+         */
+        static checkPack(unpacked) {
+            if (unpacked.length > this.l) {
+                throw new Error(`Input of size ${unpacked.length} is larger than expected size of ${l}`);
+            }
+        }
+        /**
+         *
+         * @param unpacked Array of the implemented packed type, must be shorter than the max allowed, which varies by type, will throw if the input is too long
+         * @returns Array of Fields, packed such that each Field has as much information as possible
+         *
+         * e.g. 15 Characters pack into 1 Field.  15 or fewer Characters will return an array of 1 Field
+         *      30 of fewer Characters will return an aray of 2 Fields
+         */
+        static pack(unpacked) {
+            this.checkPack(unpacked);
+            const q = this.elementsPerField();
+            let fields = [];
+            let mutableUnpacked = [...unpacked];
+            for (let i = 0; i < this.n; i++) {
+                let f = this.extractField(mutableUnpacked[i * q]);
+                if (!f) {
+                    throw new Error('Unexpected Array Length');
+                }
+                for (let j = 1; j < q; j++) {
+                    const idx = i * q + j;
+                    let value = this.extractField(mutableUnpacked[idx]);
+                    if (!value) {
+                        throw new Error('Unexpected Array Length');
+                    }
+                    value = value || Field(0);
+                    const c = Field((2n ** this.sizeInBits()) ** BigInt(j));
+                    f = f.add(value.mul(c));
+                }
+                fields.push(f);
+            }
+            return fields;
+        }
+        /**
+         *
+         * @param fields Array of Fields, packed such that each Field has as much information as possible, as returned in #pack
+         * @returns Array of bigints, which can be decoded by the implementing class into the final type
+         */
+        static unpackToBigints(fields) {
+            let uints_ = new Array(this.l); // array length is number of elements per field * number of fields
+            uints_.fill(0n);
+            let packedNs = new Array(this.n);
+            packedNs.fill(0n);
+            const packedArg = new Array(this.n);
+            packedArg.fill(Field(0), 0, this.n);
+            for (let i = 0; i < this.n; i++) {
+                if (fields[i]) {
+                    packedArg[i] = fields[i];
+                }
+            }
+            if (packedArg.length !== this.n) {
+                throw new Error(`Packed value must be exactly ${this.n} in length`);
+            }
+            for (let i = 0; i < this.n; i++) {
+                packedNs[i] = packedArg[i].toConstant().toBigInt();
+            }
+            for (let i = 0; i < packedNs.length; i++) {
+                let packedN = packedNs[i];
+                for (let j = 0; j < this.elementsPerField(); j++) {
+                    const k = i * this.elementsPerField() + j;
+                    uints_[k] = packedN & ((1n << this.sizeInBits()) - 1n);
+                    packedN >>= this.sizeInBits();
+                }
+            }
+            return uints_;
+        }
+        assertEquals(other) {
+            for (let x = 0; x < n; x++) {
+                this.packed[x].assertEquals(other.packed[x]);
+            }
+        }
+    }
+    Packed_.type = provable({ packed: Provable.Array(Field, n) }, {});
+    Packed_.l = l;
+    Packed_.n = n;
+    Packed_.bitSize = bitSize;
+    return Packed_;
+}
 //# sourceMappingURL=PackingPlant.js.map

package/build/src/lib/packed-types/PackedBool.d.ts

@@ -1,85 +1,85 @@
-import { Field, Bool } from 'o1js';
-export declare function PackedBoolFactory(l?: number): {
-    new (packed: import("o1js/dist/node/lib/field.js").Field): {
-        toBooleans(): Array<boolean>;
-        assertEquals(other: {
-            assertEquals(other: any): void;
-            packed: import("o1js/dist/node/lib/field.js").Field;
-        }): void;
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    };
-    extractField(input: Bool): Field;
-    sizeInBits(): bigint;
-    /**
-     *
-     * @param f Field, packed with the information, as returned by #pack
-     * @returns Array of Bool
-     */
-    unpack(f: Field): Bool[];
-    /**
-     *
-     * @param bools Array of Bools to be packed
-     * @returns Instance of the implementing class
-     */
-    fromBools(bools: Array<Bool>): {
-        toBooleans(): Array<boolean>;
-        assertEquals(other: {
-            assertEquals(other: any): void;
-            packed: import("o1js/dist/node/lib/field.js").Field;
-        }): void;
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    };
-    /**
-     *
-     * @param booleans Array of booleans to be packed
-     * @returns Instance of the implementing class
-     */
-    fromBooleans(booleans: Array<boolean>): {
-        toBooleans(): Array<boolean>;
-        assertEquals(other: {
-            assertEquals(other: any): void;
-            packed: import("o1js/dist/node/lib/field.js").Field;
-        }): void;
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    };
-    type: import("o1js/dist/node/bindings/lib/provable-snarky.js").ProvableExtended<{
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    }, {
-        packed: string;
-    }>;
-    l: number;
-    bitSize: bigint;
-    checkPack(unpacked: import("o1js/dist/node/lib/bool.js").Bool[]): void;
-    pack(unpacked: import("o1js/dist/node/lib/bool.js").Bool[]): import("o1js/dist/node/lib/field.js").Field;
-    unpackToBigints(f: import("o1js/dist/node/lib/field.js").Field): bigint[];
-    _isStruct: true;
-    toFields: (value: {
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    }) => import("o1js/dist/node/lib/field.js").Field[];
-    toAuxiliary: (value?: {
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    } | undefined) => any[];
-    fromFields: (fields: import("o1js/dist/node/lib/field.js").Field[]) => {
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    };
-    sizeInFields(): number;
-    check: (value: {
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    }) => void;
-    toInput: (x: {
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    }) => {
-        fields?: import("o1js/dist/node/lib/field.js").Field[] | undefined;
-        packed?: [import("o1js/dist/node/lib/field.js").Field, number][] | undefined;
-    };
-    toJSON: (x: {
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    }) => {
-        packed: string;
-    };
-    fromJSON: (x: {
-        packed: string;
-    }) => {
-        packed: import("o1js/dist/node/lib/field.js").Field;
-    };
-};
+import { Field, Bool } from 'o1js';
+export declare function PackedBoolFactory(l?: number): {
+    new (packed: import("o1js/dist/node/lib/field.js").Field): {
+        toBooleans(): Array<boolean>;
+        assertEquals(other: {
+            assertEquals(other: any): void;
+            packed: import("o1js/dist/node/lib/field.js").Field;
+        }): void;
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    };
+    extractField(input: Bool): Field;
+    sizeInBits(): bigint;
+    /**
+     *
+     * @param f Field, packed with the information, as returned by #pack
+     * @returns Array of Bool
+     */
+    unpack(f: Field): Bool[];
+    /**
+     *
+     * @param bools Array of Bools to be packed
+     * @returns Instance of the implementing class
+     */
+    fromBools(bools: Array<Bool>): {
+        toBooleans(): Array<boolean>;
+        assertEquals(other: {
+            assertEquals(other: any): void;
+            packed: import("o1js/dist/node/lib/field.js").Field;
+        }): void;
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    };
+    /**
+     *
+     * @param booleans Array of booleans to be packed
+     * @returns Instance of the implementing class
+     */
+    fromBooleans(booleans: Array<boolean>): {
+        toBooleans(): Array<boolean>;
+        assertEquals(other: {
+            assertEquals(other: any): void;
+            packed: import("o1js/dist/node/lib/field.js").Field;
+        }): void;
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    };
+    type: import("o1js/dist/node/bindings/lib/provable-snarky.js").ProvableExtended<{
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    }, {
+        packed: string;
+    }>;
+    l: number;
+    bitSize: bigint;
+    checkPack(unpacked: import("o1js/dist/node/lib/bool.js").Bool[]): void;
+    pack(unpacked: import("o1js/dist/node/lib/bool.js").Bool[]): import("o1js/dist/node/lib/field.js").Field;
+    unpackToBigints(f: import("o1js/dist/node/lib/field.js").Field): bigint[];
+    _isStruct: true;
+    toFields: (value: {
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    }) => import("o1js/dist/node/lib/field.js").Field[];
+    toAuxiliary: (value?: {
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    } | undefined) => any[];
+    fromFields: (fields: import("o1js/dist/node/lib/field.js").Field[]) => {
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    };
+    sizeInFields(): number;
+    check: (value: {
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    }) => void;
+    toInput: (x: {
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field.js").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field.js").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    }) => {
+        packed: string;
+    };
+    fromJSON: (x: {
+        packed: string;
+    }) => {
+        packed: import("o1js/dist/node/lib/field.js").Field;
+    };
+};

package/build/src/lib/packed-types/PackedBool.js

@@ -1,50 +1,50 @@
-import { Provable, Bool } from 'o1js';
-import { PackingPlant } from '../PackingPlant.js';
-const L = 254; // 254 1-bit booleans fit in one Field
-const SIZE_IN_BITS = 1n;
-export function PackedBoolFactory(l = L) {
-    class PackedBool_ extends PackingPlant(Bool, l, SIZE_IN_BITS) {
-        static extractField(input) {
-            return input.toField();
-        }
-        static sizeInBits() {
-            return SIZE_IN_BITS;
-        }
-        /**
-         *
-         * @param f Field, packed with the information, as returned by #pack
-         * @returns Array of Bool
-         */
-        static unpack(f) {
-            const unpacked = Provable.witness(Provable.Array(Bool, l), () => {
-                const unpacked = this.unpackToBigints(f);
-                return unpacked.map((x) => Bool.fromJSON(Boolean(x)));
-            });
-            f.assertEquals(PackedBool_.pack(unpacked));
-            return unpacked;
-        }
-        /**
-         *
-         * @param bools Array of Bools to be packed
-         * @returns Instance of the implementing class
-         */
-        static fromBools(bools) {
-            const packed = PackedBool_.pack(bools);
-            return new PackedBool_(packed);
-        }
-        /**
-         *
-         * @param booleans Array of booleans to be packed
-         * @returns Instance of the implementing class
-         */
-        static fromBooleans(booleans) {
-            const bools = booleans.map((x) => Bool(x));
-            return PackedBool_.fromBools(bools);
-        }
-        toBooleans() {
-            return PackedBool_.unpack(this.packed).map((x) => x.toBoolean());
-        }
-    }
-    return PackedBool_;
-}
+import { Provable, Bool } from 'o1js';
+import { PackingPlant } from '../PackingPlant.js';
+const L = 254; // 254 1-bit booleans fit in one Field
+const SIZE_IN_BITS = 1n;
+export function PackedBoolFactory(l = L) {
+    class PackedBool_ extends PackingPlant(Bool, l, SIZE_IN_BITS) {
+        static extractField(input) {
+            return input.toField();
+        }
+        static sizeInBits() {
+            return SIZE_IN_BITS;
+        }
+        /**
+         *
+         * @param f Field, packed with the information, as returned by #pack
+         * @returns Array of Bool
+         */
+        static unpack(f) {
+            const unpacked = Provable.witness(Provable.Array(Bool, l), () => {
+                const unpacked = this.unpackToBigints(f);
+                return unpacked.map((x) => Bool.fromJSON(Boolean(x)));
+            });
+            f.assertEquals(PackedBool_.pack(unpacked));
+            return unpacked;
+        }
+        /**
+         *
+         * @param bools Array of Bools to be packed
+         * @returns Instance of the implementing class
+         */
+        static fromBools(bools) {
+            const packed = PackedBool_.pack(bools);
+            return new PackedBool_(packed);
+        }
+        /**
+         *
+         * @param booleans Array of booleans to be packed
+         * @returns Instance of the implementing class
+         */
+        static fromBooleans(booleans) {
+            const bools = booleans.map((x) => Bool(x));
+            return PackedBool_.fromBools(bools);
+        }
+        toBooleans() {
+            return PackedBool_.unpack(this.packed).map((x) => x.toBoolean());
+        }
+    }
+    return PackedBool_;
+}
 //# sourceMappingURL=PackedBool.js.map

package/build/src/lib/packed-types/PackedBool.test.d.ts

@@ -1 +1 @@
-export {};
+export {};