@arcium-hq/client 0.6.0 → 0.6.2

package/build/index.cjs

@@ -281,6 +281,28 @@ function encodeAsRescueEncryptable(v) {
     }
     throw new Error('Invalid type to convert from number to bigint');
 }
+/**
+ * Decodes a Rescue-decrypted value back to a signed bigint.
+ * Handles the conversion from field element representation to signed integer.
+ * @param v - The decrypted field element value
+ * @returns The decoded signed bigint value
+ */
+function decodeRescueDecryptedToBigInt(v) {
+    const twoInv = (CURVE25519_BASE_FIELD.ORDER + 1n) / 2n;
+    const binSize = getBinSize(CURVE25519_BASE_FIELD.ORDER - 1n);
+    const isLtTwoInv = ctLt(v, twoInv, binSize);
+    return ctSelect(isLtTwoInv, v, ctSub(v, CURVE25519_BASE_FIELD.ORDER, binSize), binSize);
+}
+/**
+ * Decodes a Rescue-decrypted value back to a JavaScript number.
+ * Converts from field element representation to a floating-point number.
+ * @param v - The decrypted field element value
+ * @returns The decoded number value
+ */
+function decodeRescueDecryptedToNumber(v) {
+    const vSigned = decodeRescueDecryptedToBigInt(v);
+    return Number(vSigned) * 2 ** -DOUBLE_PRECISION_MANTISSA;
+}
 /**
  * Checks if a computation reference is null (all zeros).
  * @param ref - The computation reference to check
@@ -1271,22 +1293,22 @@ class Aes256Cipher extends AesCtrCipher {
 }
 
 class DataSize {
-    is_full;
+    isFull;
     size;
     index;
     constructor(index, size) {
-        const is_undefined = size == undefined;
-        this.is_full = is_undefined;
-        this.size = is_undefined ? 0 : size;
+        const isUndefined = size === undefined;
+        this.isFull = isUndefined;
+        this.size = isUndefined ? 0 : size;
         this.index = index;
     }
 }
 function sortDataSizes(arr) {
-    arr.sort((left, right) => {
-        if (left.is_full != right.is_full) {
-            return left.is_full ? -1 : 1;
+    return [...arr].sort((left, right) => {
+        if (left.isFull !== right.isFull) {
+            return left.isFull ? -1 : 1;
         }
-        if (left.size != right.size) {
+        if (left.size !== right.size) {
             return right.size - left.size;
         }
         return left.index - right.index;
@@ -1309,7 +1331,7 @@ class PackingState {
         this.maxSize = maxSize;
     }
     getCurrentLoad(index) {
-        return this.loads[index] == undefined ? 0 : this.loads[index];
+        return this.loads[index] === undefined ? 0 : this.loads[index];
     }
     canFit(index, size) {
         return this.getCurrentLoad(index) + size <= this.maxSize;
@@ -1324,7 +1346,7 @@ class PackingState {
         return this.lastInsert + 1;
     }
     insert(size) {
-        if (size.is_full) {
+        if (size.isFull) {
             this.lastInsert = this.nFull;
             this.nFull++;
             return new PackLocation(this.lastInsert, 0);
@@ -1339,23 +1361,27 @@ class PackingState {
     }
 }
 function packing(maxSize, arr) {
-    sortDataSizes(arr);
+    const sortedArr = sortDataSizes(arr);
     const inserts = [];
     const state = new PackingState(maxSize);
-    arr.forEach((value) => {
+    sortedArr.forEach((value) => {
         const pack = state.insert(value);
         inserts.push([value.index, pack]);
     });
-    const n_packs = state.loads.length;
+    const nPacks = state.nFull + state.loads.length;
     inserts.sort((left, right) => left[0] - right[0]);
     const res = inserts.map((arg) => arg[1]);
-    return [n_packs, res];
+    return [nPacks, res];
 }
 const ARCIS_PACKING_SIZE = 214;
 function arcisPacking(arr) {
     return packing(ARCIS_PACKING_SIZE, arr);
 }
 
+/** 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;
 var ArcisValueKind;
 (function (ArcisValueKind) {
     ArcisValueKind[ArcisValueKind["Integer"] = 0] = "Integer";
@@ -1377,10 +1403,10 @@ class IntegerInfo {
     minValue() {
         return this.signed ? -1n << (this.width - 1n) : 0n;
     }
-    is_within_bounds(b) {
-        const min_value = this.minValue();
-        const min_bigger_value = this.signed ? 1n << (this.width - 1n) : 1n << this.width;
-        return min_value <= b && b < min_bigger_value;
+    isWithinBounds(b) {
+        const minVal = this.minValue();
+        const maxVal = this.signed ? 1n << (this.width - 1n) : 1n << this.width;
+        return minVal <= b && b < maxVal;
     }
     name() {
         return (this.signed ? "i" : "u") + this.width;
@@ -1414,9 +1440,9 @@ class ArcisValueField {
                 kind = ArcisValueKind.Pubkey;
                 break;
         }
-        if (kind == ArcisValueKind.Integer) {
-            if (typeof rawType == "string") {
-                throw TypeError("Weird thfflkmk");
+        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);
@@ -1426,38 +1452,63 @@ class ArcisValueField {
         }
     }
     toBigInt(arg) {
+        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 arg != "boolean") {
-                    throw new TypeError("Field " + this.name + " expected a `boolean`, got `" + typeof arg + "`.");
-                }
-                return BigInt(arg);
-            case ArcisValueKind.Float:
-                if (typeof arg != "number") {
-                    throw new TypeError("Field " + this.name + " expected a `number`, got `" + typeof arg + "`.");
+                if (typeof value !== 'boolean') {
+                    throw new TypeError(`Field ${this.name} expected a boolean, got ${typeof value}`);
                 }
-                return encodeAsRescueEncryptable(arg);
+                return BigInt(value);
             case ArcisValueKind.FullInteger:
-                if (typeof arg != "bigint") {
-                    throw new TypeError("Field " + this.name + " expected a `bigint`, got `" + typeof arg + "`.");
+                if (typeof value !== 'bigint') {
+                    throw new TypeError(`Field ${this.name} expected a bigint, got ${typeof value}`);
                 }
-                return arg;
+                return value;
             case ArcisValueKind.Integer:
-                if (typeof arg != "bigint") {
-                    throw new TypeError("Field " + this.name + " expected a `bigint`, got `" + typeof arg + "`.");
+                if (typeof value !== 'bigint') {
+                    throw new TypeError(`Field ${this.name} expected a bigint, got ${typeof value}`);
                 }
-                if (typeof this.info == "undefined") {
-                    throw new TypeError("Field " + this.name + " is an integer, but signedness and width are unknown.");
+                if (this.info === undefined) {
+                    throw new TypeError(`Field ${this.name} is an integer, but signedness and width are unknown`);
                 }
-                if (!this.info.is_within_bounds(arg)) {
-                    throw new TypeError("Field " + this.name + " is a " + this.info.name() + ", and " + arg + " is not.");
+                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 arg - this.info.minValue();
-            case ArcisValueKind.Pubkey:
-                if (!(arg instanceof Uint8Array)) {
-                    throw new TypeError("Field " + this.name + " expected a `Uint8Array`, got `" + typeof arg + "`.");
+                return value - this.info.minValue();
+            case ArcisValueKind.Pubkey: {
+                if (!(value instanceof Uint8Array)) {
+                    throw new TypeError(`Field ${this.name} expected a Uint8Array, got ${typeof value}`);
                 }
-                throw new TypeError("unimplemented pubkey ");
+                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 = this.kind;
+                throw new Error(`Unhandled ArcisValueKind: ${_exhaustive}`);
+            }
         }
     }
     fromBigInt(arg) {
@@ -1469,20 +1520,57 @@ class ArcisValueField {
                     case 1n:
                         return true;
                     default:
-                        throw new Error("Bool was neither 0 nor 1, it was " + arg);
+                        throw new RangeError(`Field ${this.name}: Bool must be 0 or 1, got ${arg}`);
                 }
             case ArcisValueKind.Float:
-                return Number(arg - (1n << 127n)) / (2 ** 52);
+                return decodeRescueDecryptedToNumber(arg);
             case ArcisValueKind.FullInteger:
                 return arg;
             case ArcisValueKind.Integer:
-                if (this.info == undefined) {
-                    throw TypeError("Integer type without integer info");
+                if (this.info === undefined) {
+                    throw new TypeError("Integer type without integer info");
                 }
                 return arg + this.info.minValue();
-            case ArcisValueKind.Pubkey:
-                throw new Error("unimplemented yet");
+            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 = this.kind;
+                throw new Error(`Unhandled ArcisValueKind: ${_exhaustive}`);
+            }
+        }
+    }
+    static fromFieldInfo(info) {
+        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) {
         switch (this.kind) {
@@ -1507,6 +1595,9 @@ class ArcisType {
         this.fields = fields;
     }
     pack(rawData) {
+        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);
@@ -1521,11 +1612,14 @@ class ArcisType {
     unpack(packed) {
         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 = [];
         for (let idx = 0; idx < dataSizes.length; idx++) {
             const packLocation = packing[1][idx];
             const dataSize = dataSizes[idx];
-            const val = dataSize.is_full ? packed[packLocation.index] : (packed[packLocation.index] >> BigInt(packLocation.offset)) % (1n << BigInt(dataSize.size));
+            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;
@@ -1557,10 +1651,76 @@ class ArcisModule {
     }
 }
 
-var address = "BpaW2ZmCJnDwizWY8eM34JtVqp2kRgnmQcedSVc9USdP";
+function parseFieldName(name) {
+    const match = name.match(/^(.+)\[(\d+)\]$/);
+    if (match) {
+        return { base: match[1], index: parseInt(match[2], 10) };
+    }
+    return { base: name, index: null };
+}
+function extractValue(data, fieldName) {
+    const { base, index } = parseFieldName(fieldName);
+    const value = data[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, fieldNames) {
+    const result = {};
+    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][index] = value;
+        }
+        else {
+            result[base] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Creates a type-safe packer from field definitions.
+ * Use `as const` on the fields array for compile-time field name validation.
+ * @param fields - Field definitions from generated code.
+ * @param typeName - Type name for debugging.
+ */
+function createPacker(fields, typeName = 'Packer') {
+    const arcisFields = fields.map(f => ArcisValueField.fromFieldInfo(f));
+    const arcisType = new ArcisType(typeName, arcisFields);
+    const fieldNames = fields.map(f => f.name);
+    return {
+        pack(data) {
+            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) {
+            const arr = arcisType.unpack(packed);
+            return groupUnpackedValues(arr, fieldNames);
+        }
+    };
+}
+
+var address = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
 var metadata = {
 	name: "arcium",
-	version: "0.6.0",
+	version: "0.6.2",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -2733,18 +2893,24 @@ var instructions = [
 						{
 							kind: "const",
 							value: [
-								109,
+								77,
 								120,
 								101,
-								95,
-								114,
+								82,
 								101,
 								99,
 								111,
 								118,
 								101,
 								114,
-								121
+								121,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
@@ -3510,18 +3676,24 @@ var instructions = [
 						{
 							kind: "const",
 							value: [
-								109,
+								77,
 								120,
 								101,
-								95,
-								114,
+								82,
 								101,
 								99,
 								111,
 								118,
 								101,
 								114,
-								121
+								121,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
@@ -3865,18 +4037,24 @@ var instructions = [
 						{
 							kind: "const",
 							value: [
-								109,
+								77,
 								120,
 								101,
-								95,
-								114,
+								82,
 								101,
 								99,
 								111,
 								118,
 								101,
 								114,
-								121
+								121,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
@@ -4979,18 +5157,24 @@ var instructions = [
 						{
 							kind: "const",
 							value: [
-								109,
+								77,
 								120,
 								101,
-								95,
-								114,
+								82,
 								101,
 								99,
 								111,
 								118,
 								101,
 								114,
-								121
+								121,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
@@ -5152,18 +5336,24 @@ var instructions = [
 						{
 							kind: "const",
 							value: [
-								109,
+								77,
 								120,
 								101,
-								95,
-								114,
+								82,
 								101,
 								99,
 								111,
 								118,
 								101,
 								114,
-								121
+								121,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
@@ -7320,18 +7510,24 @@ var instructions = [
 						{
 							kind: "const",
 							value: [
-								109,
+								77,
 								120,
 								101,
-								95,
-								114,
+								82,
 								101,
 								99,
 								111,
 								118,
 								101,
 								114,
-								121
+								121,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
@@ -8560,18 +8756,24 @@ var instructions = [
 						{
 							kind: "const",
 							value: [
-								109,
+								77,
 								120,
 								101,
-								95,
-								114,
+								82,
 								101,
 								99,
 								111,
 								118,
 								101,
 								114,
-								121
+								121,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
@@ -9685,6 +9887,11 @@ var errors = [
 		code: 6713,
 		name: "BackupClusterNotSet",
 		msg: "Backup MXE cluster is not set"
+	},
+	{
+		code: 6714,
+		name: "ShareAlreadySubmitted",
+		msg: "Share already submitted"
 	}
 ];
 var types = [
@@ -11545,17 +11752,11 @@ var types = [
 			kind: "struct",
 			fields: [
 				{
-					name: "bitmap",
+					name: "key_recovery_finalize_offset",
 					docs: [
-						"Bitmap tracking which peers have uploaded their shares.",
-						"Bit index corresponds to the index in the original MXE's recovery_peers array."
+						"The computation offset for the queued key_recovery_finalize circuit."
 					],
-					type: {
-						array: [
-							"u8",
-							13
-						]
-					}
+					type: "u64"
 				},
 				{
 					name: "shares",
@@ -11581,52 +11782,32 @@ var types = [
 					}
 				},
 				{
-					name: "is_finalized",
-					docs: [
-						"Whether the recovery has been finalized (threshold met and marked ready)."
-					],
-					type: "u8"
+					name: "original_mxe_pubkey",
+					type: "pubkey"
 				},
 				{
-					name: "_padding1",
-					docs: [
-						"Padding for u64 alignment (need 5 bytes to align key_recovery_final_offset at 8-byte",
-						"boundary)"
-					],
-					type: {
-						array: [
-							"u8",
-							2
-						]
-					}
+					name: "backup_mxe_pubkey",
+					type: "pubkey"
 				},
 				{
-					name: "key_recovery_finalize_offset",
+					name: "is_finalized",
 					docs: [
-						"The computation offset for the queued key_recovery_finalize circuit."
+						"Whether the recovery has been finalized (threshold met and marked ready)."
 					],
-					type: "u64"
+					type: "u8"
 				},
 				{
 					name: "_padding2",
 					docs: [
-						"Padding to ensure struct size is multiple of 8 (for zero_copy alignment after bump field)"
+						"Padding to ensure struct size is u64 aligned (6 bytes)"
 					],
 					type: {
 						array: [
 							"u8",
-							7
+							6
 						]
 					}
 				},
-				{
-					name: "original_mxe_pubkey",
-					type: "pubkey"
-				},
-				{
-					name: "backup_mxe_pubkey",
-					type: "pubkey"
-				},
 				{
 					name: "bump",
 					type: "u8"
@@ -12615,7 +12796,7 @@ const RECOVERY_CLUSTER_ACC_SEED = 'RecoveryClusterAccount';
  * Seed for MxeRecoveryAccount PDA
  * @constant {string}
  */
-const MXE_RECOVERY_ACC_SEED = 'mxe_recovery';
+const MXE_RECOVERY_ACC_SEED = 'MxeRecoveryAccount';
 /**
  * Maximum number of bytes that can be reallocated per instruction.
  * @constant {number}
@@ -13452,8 +13633,10 @@ exports.Aes192Cipher = Aes192Cipher;
 exports.Aes256Cipher = Aes256Cipher;
 exports.ArcisModule = ArcisModule;
 exports.ArcisType = ArcisType;
+exports.ArcisValueField = ArcisValueField;
 exports.CURVE25519_BASE_FIELD = CURVE25519_BASE_FIELD;
 exports.CURVE25519_SCALAR_FIELD_MODULUS = CURVE25519_SCALAR_FIELD_MODULUS;
+exports.IntegerInfo = IntegerInfo;
 exports.Matrix = Matrix;
 exports.RescueCipher = RescueCipher;
 exports.RescueDesc = RescueDesc;
@@ -13461,6 +13644,7 @@ exports.RescuePrimeHash = RescuePrimeHash;
 exports.arcisEd25519 = arcisEd25519;
 exports.awaitComputationFinalization = awaitComputationFinalization;
 exports.buildFinalizeCompDefTx = buildFinalizeCompDefTx;
+exports.createPacker = createPacker;
 exports.deserializeLE = deserializeLE;
 exports.finalizeKeyRecoveryExecution = finalizeKeyRecoveryExecution;
 exports.generateRandomFieldElem = generateRandomFieldElem;