@arcium-hq/client 0.9.2 → 0.9.3

package/build/types/utils.d.ts

@@ -0,0 +1,65 @@
+import * as anchor from '@coral-xyz/anchor';
+import { ArciumIdlType } from './idl/index.js';
+/**
+ * Check if code is running in a browser environment.
+ * @returns true if window object exists, false otherwise.
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Conditionally logs a message if logging is enabled.
+ * @param log - Whether to output the log.
+ * @param args - Arguments to pass to console.log.
+ */
+export declare function optionalLog(log: boolean, ...args: Parameters<typeof console.log>): void;
+/**
+ * Calculate the minimum number of bits needed to represent a value.
+ * Formula: floor(log2(max)) + 1 for unsigned, +1 for signed, +1 for diff of two negatives.
+ * @param max - Bigint value to measure.
+ * @returns Number of bits required.
+ */
+export declare function getBinSize(max: bigint): bigint;
+/**
+ * Number of mantissa bits for double-precision floating point values.
+ */
+export declare const DOUBLE_PRECISION_MANTISSA = 52;
+/**
+ * Encode a value as a bigint suitable for Rescue encryption, handling booleans, bigints, and numbers.
+ * The encoding is performed in constant-time to avoid leaking information through timing side-channels.
+ * Throws if the value is out of the supported range for the field.
+ * @param v - Value to encode (bigint, number, or boolean).
+ * @returns Encoded value as a bigint.
+ */
+export declare function encodeAsRescueEncryptable(v: bigint | number | boolean): bigint;
+/**
+ * Decode a Rescue-decrypted value back to a signed bigint.
+ * Handle the conversion from field element representation to signed integer.
+ * @param v - Decrypted field element value.
+ * @returns Decoded signed bigint value.
+ */
+export declare function decodeRescueDecryptedToBigInt(v: bigint): bigint;
+/**
+ * Decode a Rescue-decrypted value back to a JavaScript number.
+ * Convert from field element representation to a floating-point number.
+ * @param v - Decrypted field element value.
+ * @returns Decoded number value.
+ */
+export declare function decodeRescueDecryptedToNumber(v: bigint): number;
+/**
+ * Generate a random integer in the range [min, max] (inclusive).
+ * @param min - Minimum value (inclusive).
+ * @param max - Maximum value (inclusive).
+ * @returns Random integer between min and max.
+ */
+export declare function randomInt(min: number, max: number): number;
+/**
+ * Reference to a computation in a mempool or executing pool.
+ * Contains the computation offset and priority fee information.
+ */
+export type ComputationReference = anchor.IdlTypes<ArciumIdlType>['computationReference'];
+/**
+ * Check if a computation reference is null (all zeros).
+ * @param ref - Computation reference to check.
+ * @returns true if the reference is null, false otherwise.
+ */
+export declare function isNullRef(ref: ComputationReference): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/build/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAG5C,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;GAGG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAKnC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,GAAG,CAAC,QAKhF;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI9C;AAED;;GAEG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAoB9E;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAK/D;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG/D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,sBAAsB,CAAC,CAAC;AAE1F;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAM5D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcium-hq/client",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Client SDK for interacting with encrypted Solana programs",
   "author": "Arcium",
   "license": "GPL-3.0-only",
@@ -14,20 +14,21 @@
     "compile": "yarn bundle:cjs && yarn bundle:esm && yarn bundle:dts",
     "bundle:cjs": "node ../../node_modules/rollup/dist/bin/rollup --config config/rollup.config.cjs.js",
     "bundle:esm": "node ../../node_modules/rollup/dist/bin/rollup --config config/rollup.config.esm.js",
-    "bundle:dts": "node ../../node_modules/rollup/dist/bin/rollup --config config/rollup.config.dts.js",
+    "bundle:dts": "tsc --emitDeclarationOnly",
     "test-single": "mocha $1 --exit"
   },
   "type": "module",
   "module": "build/index.mjs",
-  "types": "build/index.d.ts",
+  "types": "build/types/index.d.ts",
   "files": [
     "build/index.cjs",
     "build/index.mjs",
-    "build/index.d.ts"
+    "build/types/",
+    "src/"
   ],
   "exports": [
     {
-      "types": "./build/index.d.ts",
+      "types": "./build/types/index.d.ts",
       "import": "./build/index.mjs",
       "require": "./build/index.cjs"
     }
@@ -52,7 +53,6 @@
     "eslint-plugin-import": "^2.31.0",
     "mocha": "^10.8.2",
     "rollup": "^4.24.0",
-    "rollup-plugin-dts": "^6.1.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.6.3",
     "typescript-eslint": "^8.15.0"

package/src/arcis/arcisModule.ts

@@ -0,0 +1,39 @@
+import {ArcisType} from "./arcisType.js";
+import fs from "fs";
+
+/**
+ * Container for circuit type definitions.
+ * Loaded from generated JSON files by build tools -- not typically used directly.
+ * @internal
+ */
+export class ArcisModule {
+    /** Map of type name to parsed ArcisType. */
+    types: {[typeName: string]: ArcisType};
+
+    constructor(types: {[typeName: string]: ArcisType}) {
+        this.types = types;
+    }
+
+    /**
+     * Parse module from JSON object (as produced by the Arcium compiler).
+     * @param json - Raw JSON object with type name keys.
+     */
+    public static fromJson(json: unknown): ArcisModule {
+        const typedJson = json as { [typeName: string]: unknown };
+        const res: {[typeName: string]: ArcisType} = {};
+        for (const key in typedJson) {
+            res[key] = ArcisType.fromJson(key, typedJson[key]);
+        }
+        return new ArcisModule(res);
+    }
+
+    /**
+     * Load module from a JSON file on disk.
+     * @param path - Absolute or relative path to the JSON file.
+     */
+    public static loadFromFile(path: string): ArcisModule {
+        const file = fs.readFileSync(path);
+        const json = JSON.parse(file.toString());
+        return ArcisModule.fromJson(json);
+    }
+}

package/src/arcis/arcisType.ts

@@ -0,0 +1,303 @@
+import {arcisPacking, DataSize} from "./packing.js";
+import {encodeAsRescueEncryptable, decodeRescueDecryptedToNumber} from "../utils.js";
+
+/** Length of a Pubkey in bytes (Solana public keys are 32 bytes) */
+const PUBKEY_BYTE_LENGTH = 32;
+
+/** Maximum value a Pubkey bigint can hold (2^256) */
+const PUBKEY_MAX_VALUE = 1n << 256n;
+
+/**
+ * Field definition for circuit input/output packing.
+ * Pass an array of these to {@link createPacker} to create a type-safe packer.
+ *
+ * @example
+ * import { FieldInfo } from '@arcium-hq/client';
+ *
+ * const fields: FieldInfo[] = [
+ *   { name: 'amount', type: { Integer: { signed: false, width: 64 } } },
+ *   { name: 'active', type: 'Bool' },
+ * ];
+ */
+export interface FieldInfo {
+    /** Field name matching the circuit parameter. For array types, use indexed notation (`bytes[0]`, `bytes[1]`) - the packer groups these back into arrays on unpack. */
+    name: string;
+    /** Field type: Integer with sign/width, Bool, FullInteger (256-bit), Float, or Pubkey. */
+    type: { Integer: { signed: boolean; width: number } } | 'Bool' | 'FullInteger' | 'Float' | 'Pubkey';
+}
+
+enum ArcisValueKind {
+    Integer,
+    FullInteger,
+    Bool,
+    Float,
+    Pubkey,
+}
+
+/**
+ * Integer type metadata. Used internally by packer.
+ * @internal
+ */
+export class IntegerInfo {
+    signed: boolean;
+    width: bigint;
+    constructor(signed:boolean, width: bigint) {
+        this.signed = signed;
+        this.width = width;
+    }
+    public static fromJson(json: { "signed": boolean, "width": number}): IntegerInfo {
+        return new IntegerInfo(json.signed, BigInt(json.width));
+    }
+
+    minValue(): bigint {
+        return this.signed ? -1n << (this.width - 1n) : 0n;
+    }
+    isWithinBounds(b: bigint): boolean {
+        const minVal = this.minValue();
+        const maxVal = this.signed ? 1n << (this.width - 1n) : 1n << this.width;
+        return minVal <= b && b < maxVal;
+    }
+    name(): string {
+        return (this.signed ? "i" : "u") + this.width;
+    }
+}
+
+/**
+ * Runtime field representation. Used internally by packer.
+ * @internal
+ */
+export class ArcisValueField {
+    name: string;
+    kind: ArcisValueKind;
+    info: IntegerInfo | undefined;
+    constructor(name: string, kind: ArcisValueKind, info?: IntegerInfo) {
+        this.name = name;
+        this.kind = kind;
+        this.info = info;
+    }
+    public static fromJson(json: unknown): ArcisValueField {
+        const typedJson = json as { "name": string, "type": unknown};
+        const name = typedJson["name"];
+        const rawType = typedJson["type"] as string | {"Integer": { "signed": boolean, "width": number}};
+        let kind = ArcisValueKind.Integer;
+        switch (rawType) {
+            case "FullInteger":
+                kind = ArcisValueKind.FullInteger;
+                break;
+            case "Bool":
+                kind = ArcisValueKind.Bool;
+                break;
+            case "Float":
+                kind = ArcisValueKind.Float;
+                break;
+            case "Pubkey":
+                kind = ArcisValueKind.Pubkey;
+                break;
+        }
+        if (kind === ArcisValueKind.Integer) {
+            if (typeof rawType === "string") {
+                throw new TypeError("Expected Integer type object with signed/width properties");
+            }
+            const info = IntegerInfo.fromJson(rawType.Integer);
+            return new ArcisValueField(name, kind, info);
+        }
+        else {
+            return new ArcisValueField(name, kind);
+        }
+    }
+
+    toBigInt(arg: unknown): bigint {
+        if (this.kind === ArcisValueKind.Float) {
+            if (typeof arg !== 'number') {
+                throw new TypeError(`Field ${this.name} expected a number, got ${typeof arg}`);
+            }
+            return encodeAsRescueEncryptable(arg);
+        }
+
+        let value = arg;
+        if (typeof value === 'number') {
+            if (!Number.isInteger(value)) {
+                throw new TypeError(`Field ${this.name}: expected integer, got float ${value}`);
+            }
+            if (!Number.isSafeInteger(value)) {
+                throw new RangeError(`Field ${this.name}: ${value} exceeds safe integer range, use BigInt`);
+            }
+            value = BigInt(value);
+        }
+
+        switch (this.kind) {
+            case ArcisValueKind.Bool:
+                if (typeof value !== 'boolean') {
+                    throw new TypeError(`Field ${this.name} expected a boolean, got ${typeof value}`);
+                }
+                return BigInt(value);
+            case ArcisValueKind.FullInteger:
+                if (typeof value !== 'bigint') {
+                    throw new TypeError(`Field ${this.name} expected a bigint, got ${typeof value}`);
+                }
+                return value;
+            case ArcisValueKind.Integer:
+                if (typeof value !== 'bigint') {
+                    throw new TypeError(`Field ${this.name} expected a bigint, got ${typeof value}`);
+                }
+                if (this.info === undefined) {
+                    throw new TypeError(`Field ${this.name} is an integer, but signedness and width are unknown`);
+                }
+                if (!this.info.isWithinBounds(value)) {
+                    const min = this.info.minValue();
+                    const max = this.info.signed ? (1n << (this.info.width - 1n)) - 1n : (1n << this.info.width) - 1n;
+                    throw new RangeError(`Field "${this.name}" (${this.info.name()}): value ${value} out of range [${min}, ${max}]`);
+                }
+                return value - this.info.minValue();
+            case ArcisValueKind.Pubkey: {
+                if (!(value instanceof Uint8Array)) {
+                    throw new TypeError(`Field ${this.name} expected a Uint8Array, got ${typeof value}`);
+                }
+                if (value.length !== PUBKEY_BYTE_LENGTH) {
+                    throw new RangeError(`Field ${this.name} expected ${PUBKEY_BYTE_LENGTH}-byte Uint8Array, got ${value.length} bytes`);
+                }
+                let pubkeyResult = 0n;
+                for (let i = 0; i < PUBKEY_BYTE_LENGTH; i++) {
+                    pubkeyResult |= BigInt(value[i]) << BigInt(i * 8);
+                }
+                return pubkeyResult;
+            }
+            default: {
+                const _exhaustive: never = this.kind;
+                throw new Error(`Unhandled ArcisValueKind: ${_exhaustive}`);
+            }
+        }
+    }
+    fromBigInt(arg: bigint): boolean | number | bigint | Uint8Array {
+        switch (this.kind) {
+            case ArcisValueKind.Bool:
+                switch (arg) {
+                    case 0n:
+                        return false;
+                    case 1n:
+                        return true;
+                    default:
+                        throw new RangeError(`Field ${this.name}: Bool must be 0 or 1, got ${arg}`);
+                }
+            case ArcisValueKind.Float:
+                return decodeRescueDecryptedToNumber(arg);
+            case ArcisValueKind.FullInteger:
+                return arg;
+            case ArcisValueKind.Integer:
+                if (this.info === undefined) {
+                    throw new TypeError("Integer type without integer info");
+                }
+                return arg + this.info.minValue();
+            case ArcisValueKind.Pubkey: {
+                if (arg < 0n) {
+                    throw new RangeError(`Field ${this.name}: Pubkey cannot be negative`);
+                }
+                if (arg >= PUBKEY_MAX_VALUE) {
+                    throw new RangeError(`Field ${this.name}: Pubkey exceeds 256 bits`);
+                }
+                const pubkeyBytes = new Uint8Array(PUBKEY_BYTE_LENGTH);
+                let remaining = arg;
+                for (let i = 0; i < PUBKEY_BYTE_LENGTH; i++) {
+                    pubkeyBytes[i] = Number(remaining & 0xFFn);
+                    remaining >>= 8n;
+                }
+                return pubkeyBytes;
+            }
+            default: {
+                const _exhaustive: never = this.kind;
+                throw new Error(`Unhandled ArcisValueKind: ${_exhaustive}`);
+            }
+        }
+    }
+
+    public static fromFieldInfo(info: FieldInfo): ArcisValueField {
+        const name = info.name;
+        if (info.type === 'Bool') {
+            return new ArcisValueField(name, ArcisValueKind.Bool);
+        }
+        if (info.type === 'FullInteger') {
+            return new ArcisValueField(name, ArcisValueKind.FullInteger);
+        }
+        if (info.type === 'Float') {
+            return new ArcisValueField(name, ArcisValueKind.Float);
+        }
+        if (info.type === 'Pubkey') {
+            return new ArcisValueField(name, ArcisValueKind.Pubkey);
+        }
+        if (typeof info.type === 'object' && 'Integer' in info.type) {
+            const intInfo = new IntegerInfo(
+                info.type.Integer.signed,
+                BigInt(info.type.Integer.width)
+            );
+            return new ArcisValueField(name, ArcisValueKind.Integer, intInfo);
+        }
+        throw new TypeError(`Unknown field type for ${name}`);
+    }
+
+    toDataSize(index: number): DataSize {
+        switch (this.kind) {
+            case ArcisValueKind.Pubkey:
+                return new DataSize(index);
+            case ArcisValueKind.Integer:
+                return new DataSize(index, Number(this.info?.width));
+            case ArcisValueKind.FullInteger:
+                return new DataSize(index);
+            case ArcisValueKind.Bool:
+                return new DataSize(index, 1);
+            case ArcisValueKind.Float:
+                return new DataSize(index);
+        }
+    }
+
+}
+
+/**
+ * Type container for pack/unpack operations. Used internally by packer.
+ * @internal
+ */
+export class ArcisType {
+    name: string;
+    fields: ArcisValueField[];
+    constructor(name: string, fields: ArcisValueField[]) {
+        this.name = name;
+        this.fields = fields;
+    }
+
+    pack(rawData: unknown[]): bigint[] {
+        if (rawData.length !== this.fields.length) {
+            throw new RangeError(`Expected ${this.fields.length} fields, got ${rawData.length}`);
+        }
+        const data = rawData.map((val, index) => this.fields[index].toBigInt(val));
+        const dataSizes = this.fields.map((field, index) => field.toDataSize(index));
+        const packing = arcisPacking(dataSizes);
+        const plaintext: bigint[] = Array(packing[0]);
+        plaintext.fill(0n);
+        for (let idx = 0; idx < data.length; idx++) {
+            const packLocation = packing[1][idx];
+            plaintext[packLocation.index] += data[idx] << BigInt(packLocation.offset);
+        }
+        return plaintext
+    }
+    unpack(packed: bigint[]): (boolean | number | bigint | Uint8Array)[] {
+        const dataSizes = this.fields.map((field, index) => field.toDataSize(index));
+        const packing = arcisPacking(dataSizes);
+        if (packed.length < packing[0]) {
+            throw new RangeError(`Expected at least ${packing[0]} packed elements, got ${packed.length}`);
+        }
+        const res: (boolean | number | bigint | Uint8Array)[] = [];
+        for (let idx = 0; idx < dataSizes.length; idx++) {
+            const packLocation = packing[1][idx];
+            const dataSize = dataSizes[idx];
+            const val = dataSize.isFull ? packed[packLocation.index] : (packed[packLocation.index] >> BigInt(packLocation.offset)) % (1n << BigInt(dataSize.size));
+            res.push(this.fields[idx].fromBigInt(val));
+        }
+        return res;
+    }
+
+    public static fromJson(name: string, json: unknown): ArcisType {
+        const typedJson = json as unknown[];
+        const fields = typedJson.map(ArcisValueField.fromJson);
+        return new ArcisType(name, fields);
+    }
+
+}

package/src/arcis/packer.ts

@@ -0,0 +1,152 @@
+import { ArcisType, ArcisValueField, FieldInfo } from "./arcisType.js";
+
+/**
+ * Type-safe packer for converting between TypeScript objects and circuit-compatible bigint arrays.
+ *
+ * @template TInput - Input object type with field names as keys
+ * @template TOutput - Output object type (typically same structure as input)
+ */
+export interface Packer<TInput, TOutput> {
+    /**
+     * Pack input values into bigint array for circuit execution.
+     * @param data - Object with field values matching the packer's field definitions.
+     * @returns Packed bigint array ready for encryption.
+     * @throws Error if a required field is missing.
+     */
+    pack(data: TInput): bigint[];
+
+    /**
+     * Unpack circuit output back to typed object.
+     * @param packed - Bigint array from decrypted circuit output.
+     * @returns Typed object with field values.
+     */
+    unpack(packed: bigint[]): TOutput;
+}
+
+/** Extracts base field name from array-indexed names: "bytes[0]" -> "bytes" */
+type ExtractBaseName<T extends string> =
+    T extends `${infer Base}[${string}]` ? Base : T;
+
+/** Extracts all base field names from a readonly FieldInfo array. */
+type FieldBaseNames<T extends readonly FieldInfo[]> =
+    ExtractBaseName<T[number]['name']>;
+
+/**
+ * Validates that field base names match TInput keys. Returns `never` on mismatch.
+ * Only validates when using `as const`; skipped if types widen to `string`.
+ */
+type ValidateFieldNames<TInput, TFields extends readonly FieldInfo[]> =
+    string extends FieldBaseNames<TFields>
+        ? TFields
+        : FieldBaseNames<TFields> extends keyof TInput
+            ? TFields
+            : never;
+
+function parseFieldName(name: string): { base: string; index: number | null } {
+    const match = name.match(/^(.+)\[(\d+)\]$/);
+    if (match) {
+        return { base: match[1], index: parseInt(match[2], 10) };
+    }
+    return { base: name, index: null };
+}
+
+function extractValue<T extends Record<string, unknown>>(
+    data: T,
+    fieldName: string
+): unknown {
+    const { base, index } = parseFieldName(fieldName);
+    const value = (data as Record<string, unknown>)[base];
+
+    if (index !== null) {
+        if (!Array.isArray(value)) {
+            throw new TypeError(`Field "${base}" should be an array`);
+        }
+        if (index >= value.length) {
+            throw new RangeError(`Field "${base}[${index}]" out of bounds (array length: ${value.length})`);
+        }
+        return value[index];
+    }
+
+    return value;
+}
+
+function groupUnpackedValues(
+    values: (boolean | number | bigint | Uint8Array)[],
+    fieldNames: string[]
+): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    for (let i = 0; i < fieldNames.length; i++) {
+        const { base, index } = parseFieldName(fieldNames[i]);
+        const value = values[i];
+        if (index !== null) {
+            if (!result[base]) {
+                result[base] = [];
+            }
+            (result[base] as unknown[])[index] = value;
+        }
+        else {
+            result[base] = value;
+        }
+    }
+    return result;
+}
+
+/**
+ * Create a type-safe packer from field definitions.
+ *
+ * Use `as const` on the fields array to enable compile-time field name validation.
+ *
+ * @param fields - Array of {@link FieldInfo} objects defining each field's name and type.
+ * @param typeName - Optional name for debugging (default: 'Packer').
+ * @returns Packer instance with pack() and unpack() methods.
+ * @throws TypeError if field types don't match expected values during pack/unpack.
+ * @throws RangeError if array index is out of bounds.
+ *
+ * @example
+ * import { createPacker } from '@arcium-hq/client';
+ *
+ * // Define fields matching your circuit's input type
+ * const fields = [
+ *   { name: 'a', type: { Integer: { signed: false, width: 32 } } },
+ *   { name: 'b', type: { Integer: { signed: false, width: 32 } } },
+ * ] as const;
+ *
+ * // Create packer with explicit input/output types
+ * const packer = createPacker<{ a: number; b: number }, { a: bigint; b: bigint }>(fields);
+ *
+ * // Pack values for circuit input
+ * const packed = packer.pack({ a: 10, b: 20 });
+ *
+ * // Unpack circuit output (from decrypted computation result)
+ * const result = packer.unpack(decryptedOutput);
+ */
+export function createPacker<
+    TInput extends Record<string, unknown>,
+    TOutput extends Record<string, unknown>,
+    const TFields extends readonly FieldInfo[] = readonly FieldInfo[]
+>(
+    fields: TFields & ValidateFieldNames<TInput, TFields>,
+    typeName: string = 'Packer'
+): Packer<TInput, TOutput> {
+    const arcisFields = fields.map(f => ArcisValueField.fromFieldInfo(f));
+    const arcisType = new ArcisType(typeName, arcisFields);
+    const fieldNames = fields.map(f => f.name);
+
+    return {
+        pack(data: TInput): bigint[] {
+            const arr = fieldNames.map(name => {
+                const value = extractValue(data, name);
+                if (value === undefined) {
+                    throw new Error(`Missing required field: "${name}"`);
+                }
+                return value;
+            });
+            return arcisType.pack(arr);
+        },
+
+        unpack(packed: bigint[]): TOutput {
+            const arr = arcisType.unpack(packed);
+            return groupUnpackedValues(arr, fieldNames) as TOutput;
+        }
+    };
+}