@arcium-hq/reader 0.1.45

package/README.md

@@ -0,0 +1,126 @@
+# Arcium Reader SDK
+
+The Arcium Reader SDK is a TypeScript library designed for passively observing and querying the state of the Arcium program on Solana. It allows you to fetch information about Arcium accounts and track the status of computations without requiring a signer.
+
+## Installation
+
+```bash
+npm install @arcium-hq/reader
+
+or
+
+```bash
+yarn add @arcium-hq/reader
+
+or
+
+```bash
+pnpm add @arcium-hq/reader
+```
+
+## Usage
+
+### Getting the Read-only Program
+
+To interact with the reader functions, you first need a read-only instance of the Arcium Anchor program. This doesn't require a wallet or signer.
+
+```typescript
+import * as anchor from "@coral-xyz/anchor";
+import { getArciumProgramReadonly } from "@arcium-hq/reader";
+
+// Assuming you have an AnchorProvider configured (e.g., from anchor.AnchorProvider.env())
+const provider = anchor.getProvider();
+const arciumProgram = getArciumProgramReadonly(provider as anchor.AnchorProvider);
+```
+
+### Fetching Account Information
+
+The reader SDK provides functions to fetch and deserialize various Arcium account types.
+
+**1. Fetching MXE Accounts:**
+
+```typescript
+import { getMXEAccs, getMXEAccInfo } from "@arcium-hq/reader";
+
+// Get all MXE account public keys
+const mxeAccPubkeys = await getMXEAccs(provider.connection);
+
+// Get detailed info for a specific MXE account
+if (mxeAccPubkeys.length > 0) {
+  const mxeAccInfo = await getMXEAccInfo(arciumProgram, mxeAccPubkeys[0]);
+  console.log("MXE Account Info:", mxeAccInfo);
+  // Access fields like mxeAccInfo.computationDefinitions, mxeAccInfo.cluster, etc.
+}
+```
+
+**2. Fetching Cluster Accounts:**
+
+```typescript
+import { getClusterAccs, getClusterAccInfo } from "@arcium-hq/reader";
+
+// Get all Cluster account public keys
+const clusterAccPubkeys = await getClusterAccs(provider.connection);
+
+// Get detailed info for a specific Cluster account
+if (clusterAccPubkeys.length > 0) {
+  const clusterInfo = await getClusterAccInfo(arciumProgram, clusterAccPubkeys[0]);
+  console.log("Cluster Account Info:", clusterInfo);
+  // Access fields like clusterInfo.mxes, clusterInfo.nodes, etc.
+}
+```
+
+**3. Fetching ArxNode Accounts:**
+
+```typescript
+import { getArxNodeAccs, getArxNodeAccInfo } from "@arcium-hq/reader";
+
+// Get all ArxNode account public keys
+const arxNodeAccPubkeys = await getArxNodeAccs(provider.connection);
+
+// Get detailed info for a specific ArxNode account
+if (arxNodeAccPubkeys.length > 0) {
+  const arxNodeInfo = await getArxNodeAccInfo(arciumProgram, arxNodeAccPubkeys[0]);
+  console.log("ArxNode Account Info:", arxNodeInfo);
+  // Access fields like arxNodeInfo.clusterMemberships, etc.
+}
+```
+
+### Tracking Computation Status
+
+You can subscribe to events related to a specific MXE (identified by its program ID) to track the lifecycle of computations it processes.
+
+```typescript
+import { subscribeComputations, unsubscribeComputations } from "@arcium-hq/reader";
+import { PublicKey } from "@solana/web3.js";
+
+// Assuming `mxeProgramId` is the PublicKey of the MXE program you want to monitor
+const mxeProgramId = new PublicKey("YOUR_MXE_PROGRAM_ID"); 
+
+const eventLog = [];
+
+// Define a callback function to handle events
+const eventCallback = (eventData: any, eventName: string) => {
+  console.log(`Received event: ${eventName}`, eventData);
+  eventLog.push({ event: eventData, name: eventName });
+  // Events typically include QueueComputationEvent, InitComputationEvent, 
+  // CallbackComputationEvent, FinalizeComputationEvent
+};
+
+// Start subscribing
+console.log(`Subscribing to computation events for ${mxeProgramId.toBase58()}`)
+const subscriptionId = await subscribeComputations(
+  provider.connection,
+  mxeProgramId, 
+  eventCallback
+);
+
+console.log(`Subscription active with ID: ${subscriptionId}`);
+
+// ... later, when you want to stop listening ...
+
+// Unsubscribe
+await unsubscribeComputations(provider.connection, subscriptionId);
+console.log(`Unsubscribed from computation events.`);
+
+```
+

package/build/index.cjs

@@ -0,0 +1,200 @@
+'use strict';
+
+var client = require('@arcium-hq/client');
+var anchor = require('@coral-xyz/anchor');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var anchor__namespace = /*#__PURE__*/_interopNamespaceDefault(anchor);
+
+const ARCIUM_PROGRAM_ID_STRING = 'BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6';
+const ARX_NODE_ACC_DISCRIMINATOR = [2, 207, 122, 223, 93, 97, 231, 199];
+const CLUSTER_ACC_DISCRIMINATOR = [236, 225, 118, 228, 173, 106, 18, 60];
+const MXE_ACC_DISCRIMINATOR = [32, 115, 16, 240, 209, 25, 92, 165];
+const ARCIUM_PROGRAM_ID = new anchor__namespace.web3.PublicKey(ARCIUM_PROGRAM_ID_STRING);
+new anchor__namespace.BorshInstructionCoder(client.ARCIUM_IDL);
+const ARCIUM_EVENT_CODER = new anchor__namespace.EventParser(ARCIUM_PROGRAM_ID, new anchor__namespace.BorshCoder(client.ARCIUM_IDL));
+
+// Returns all MXE accounts
+async function getMXEAccs(conn) {
+    return getArciumAccPubkeys(conn, MXE_ACC_DISCRIMINATOR);
+}
+// Returns all Cluster accounts
+async function getClusterAccs(conn) {
+    return getArciumAccPubkeys(conn, CLUSTER_ACC_DISCRIMINATOR);
+}
+// Returns all ArxNode accounts
+async function getArxNodeAccs(conn) {
+    return getArciumAccPubkeys(conn, ARX_NODE_ACC_DISCRIMINATOR);
+}
+// Fetches and parses a given MXE account. Format:
+async function getMXEAccInfo(arciumProgram, address, commitment) {
+    return arciumProgram.account.persistentMxeAccount.fetch(address, commitment);
+}
+async function getClusterAccInfo(arciumProgram, address, commitment) {
+    return arciumProgram.account.cluster.fetch(address, commitment);
+}
+async function getArxNodeAccInfo(arciumProgram, address, commitment) {
+    return arciumProgram.account.arxNode.fetch(address, commitment);
+}
+async function getComputationsInMempool(arciumProgram, address) {
+    const mempool = await client.getMempoolAccData(arciumProgram.provider, address);
+    const startIndex = mempool.inner.computations.startIndex;
+    const length = mempool.inner.computations.length;
+    const elems = mempool.inner.computations.elems;
+    function isValid(validBits, idx) {
+        const byte = idx >>> 3;
+        const bit = idx & 7;
+        if (byte >= validBits.length) {
+            // This should never happen, so we'll want to know about it
+            throw new Error(`isValid: byte ${byte} >= validBits.length ${validBits.length}`);
+        }
+        return (validBits[byte] & (1 << bit)) !== 0;
+    }
+    // Handle circular buffer wraparound
+    const refs = [];
+    for (let i = 0; i < length; i++) {
+        const idx = (startIndex + i) % elems.length;
+        // Only save non-stake computations
+        if (isValid(mempool.inner.computations.validBits, idx)) {
+            refs.push(...elems[idx].entries);
+        }
+    }
+    return refs.flat().filter((ref) => !isNullRef(ref));
+}
+async function getComputation(arciumProgram, address, commitment) {
+    return arciumProgram.account.computationAccount.fetch(address, commitment);
+}
+async function getArciumAccPubkeys(conn, discriminator) {
+    const accs = await conn.getProgramAccounts(ARCIUM_PROGRAM_ID, {
+        dataSlice: { offset: 0, length: 0 },
+        filters: [{
+                memcmp: {
+                    offset: 0,
+                    encoding: 'base64',
+                    bytes: Buffer.from(discriminator).toString('base64'),
+                },
+            }],
+    });
+    return accs.map((acc) => acc.pubkey);
+}
+function isNullRef(ref) {
+    const bigZero = new anchor__namespace.BN(0);
+    return ref.computationDefinitionOffset === 0 && ref.computationOffset === bigZero && ref.priorityFee === bigZero;
+}
+
+const ArciumEventNames = [
+    'QueueComputationEvent',
+    'InitComputationEvent',
+    'CallbackComputationEvent',
+    'FinalizeComputationEvent',
+];
+async function subscribeComputations(conn, mxeProgramId, callback) {
+    return conn.onLogs(mxeProgramId, (logs) => {
+        const events = getComputationEventsFromLogs(logs.logs);
+        for (const event of events) {
+            callback(event.event, event.name);
+        }
+    });
+}
+async function unsubscribeComputations(conn, subscriptionId) {
+    conn.removeOnLogsListener(subscriptionId);
+}
+/**
+ * Get the computation offset from a transaction
+ * @param tx - The transaction to get the computation offset from
+ * @returns The computation offset if one is found, otherwise null.
+ * @throws Error if multiple computation offsets are found in the transaction
+ */
+function getComputationOffset(tx) {
+    const events = getComputationEventsFromLogs(tx.meta?.logMessages ?? []);
+    if (events.length === 0) {
+        return undefined;
+    }
+    const computationOffsets = events.map((e) => e.event.computationOffset);
+    const computationOffset = computationOffsets[0];
+    if (computationOffsets.some((offset) => offset !== computationOffset)) {
+        throw new Error(`Multiple computation offsets found in computation: ${JSON.stringify(computationOffsets)}`);
+    }
+    return computationOffset;
+}
+/**
+ * Get the events related to arcium computations from a transaction's logs
+ * @param logs - The logs to get the events from
+ * @returns The events in the logs.
+ */
+function getComputationEventsFromLogs(logs) {
+    return Array.from(ARCIUM_EVENT_CODER.parseLogs(logs))
+        .filter((e) => ArciumEventNames.includes(e.name))
+        .map((e) => ({
+        event: e.data,
+        name: e.name,
+    }));
+}
+
+Object.defineProperty(exports, "getArciumProgramReadonly", {
+    enumerable: true,
+    get: function () { return client.getArciumProgramReadonly; }
+});
+Object.defineProperty(exports, "getArxNodeAcc", {
+    enumerable: true,
+    get: function () { return client.getArxNodeAcc; }
+});
+Object.defineProperty(exports, "getClockAcc", {
+    enumerable: true,
+    get: function () { return client.getClockAcc; }
+});
+Object.defineProperty(exports, "getClusterAcc", {
+    enumerable: true,
+    get: function () { return client.getClusterAcc; }
+});
+Object.defineProperty(exports, "getCompDefAcc", {
+    enumerable: true,
+    get: function () { return client.getCompDefAcc; }
+});
+Object.defineProperty(exports, "getComputationAcc", {
+    enumerable: true,
+    get: function () { return client.getComputationAcc; }
+});
+Object.defineProperty(exports, "getExecutingPoolAcc", {
+    enumerable: true,
+    get: function () { return client.getExecutingPoolAcc; }
+});
+Object.defineProperty(exports, "getMXEAccAcc", {
+    enumerable: true,
+    get: function () { return client.getMXEAccAcc; }
+});
+Object.defineProperty(exports, "getMempoolAcc", {
+    enumerable: true,
+    get: function () { return client.getMempoolAcc; }
+});
+Object.defineProperty(exports, "getStakingPoolAcc", {
+    enumerable: true,
+    get: function () { return client.getStakingPoolAcc; }
+});
+exports.getArxNodeAccInfo = getArxNodeAccInfo;
+exports.getArxNodeAccs = getArxNodeAccs;
+exports.getClusterAccInfo = getClusterAccInfo;
+exports.getClusterAccs = getClusterAccs;
+exports.getComputation = getComputation;
+exports.getComputationOffset = getComputationOffset;
+exports.getComputationsInMempool = getComputationsInMempool;
+exports.getMXEAccInfo = getMXEAccInfo;
+exports.getMXEAccs = getMXEAccs;
+exports.subscribeComputations = subscribeComputations;
+exports.unsubscribeComputations = unsubscribeComputations;

package/build/index.d.ts

@@ -0,0 +1,41 @@
+import { ArciumIdlType } from '@arcium-hq/client';
+export { getArciumProgramReadonly, getArxNodeAcc, getClockAcc, getClusterAcc, getCompDefAcc, getComputationAcc, getExecutingPoolAcc, getMXEAccAcc, getMempoolAcc, getStakingPoolAcc } from '@arcium-hq/client';
+import * as anchor from '@coral-xyz/anchor';
+
+type PublicKey = anchor.web3.PublicKey;
+type Connection = anchor.web3.Connection;
+type Program<T extends anchor.Idl> = anchor.Program<T>;
+type ArciumTypes = anchor.IdlTypes<ArciumIdlType>;
+type ArciumEvent = anchor.IdlEvents<ArciumIdlType>;
+type ArciumEventName = Capitalize<keyof ArciumEvent>;
+type ArciumEventData = ArciumEvent[keyof ArciumEvent];
+type MXEAccount = ArciumTypes['persistentMxeAccount'];
+type ClusterAccount = ArciumTypes['cluster'];
+type ArxNodeAccount = ArciumTypes['arxNode'];
+type Computation = ArciumTypes['computationAccount'];
+type ComputationReference = ArciumTypes['computationReference'];
+type QueueComputationIx = ArciumIdlType['instructions']['37'];
+type CallbackComputationIx = ArciumIdlType['instructions']['4'];
+type FinalizeComputationIx = ArciumIdlType['instructions']['17'];
+type ComputationStatus = 'queued' | 'executing' | 'executed' | 'finalized' | 'failed';
+
+declare function getMXEAccs(conn: Connection): Promise<PublicKey[]>;
+declare function getClusterAccs(conn: Connection): Promise<PublicKey[]>;
+declare function getArxNodeAccs(conn: Connection): Promise<PublicKey[]>;
+declare function getMXEAccInfo(arciumProgram: anchor.Program<ArciumIdlType>, address: PublicKey, commitment?: anchor.web3.Commitment): Promise<MXEAccount>;
+declare function getClusterAccInfo(arciumProgram: anchor.Program<ArciumIdlType>, address: PublicKey, commitment?: anchor.web3.Commitment): Promise<ClusterAccount>;
+declare function getArxNodeAccInfo(arciumProgram: anchor.Program<ArciumIdlType>, address: PublicKey, commitment?: anchor.web3.Commitment): Promise<ArxNodeAccount>;
+declare function getComputationsInMempool(arciumProgram: anchor.Program<ArciumIdlType>, address: PublicKey): Promise<ComputationReference[]>;
+declare function getComputation(arciumProgram: anchor.Program<ArciumIdlType>, address: PublicKey, commitment?: anchor.web3.Commitment): Promise<Computation>;
+
+declare function subscribeComputations(conn: Connection, mxeProgramId: PublicKey, callback: (event: ArciumEventData, name: ArciumEventName) => void): Promise<number>;
+declare function unsubscribeComputations(conn: Connection, subscriptionId: number): Promise<void>;
+/**
+ * Get the computation offset from a transaction
+ * @param tx - The transaction to get the computation offset from
+ * @returns The computation offset if one is found, otherwise null.
+ * @throws Error if multiple computation offsets are found in the transaction
+ */
+declare function getComputationOffset(tx: anchor.web3.VersionedTransactionResponse): anchor.BN | undefined;
+
+export { type ArciumEvent, type ArciumEventData, type ArciumEventName, type ArciumTypes, type ArxNodeAccount, type CallbackComputationIx, type ClusterAccount, type Computation, type ComputationReference, type ComputationStatus, type Connection, type FinalizeComputationIx, type MXEAccount, type Program, type PublicKey, type QueueComputationIx, getArxNodeAccInfo, getArxNodeAccs, getClusterAccInfo, getClusterAccs, getComputation, getComputationOffset, getComputationsInMempool, getMXEAccInfo, getMXEAccs, subscribeComputations, unsubscribeComputations };

package/build/index.mjs

@@ -0,0 +1,130 @@
+import { ARCIUM_IDL, getMempoolAccData } from '@arcium-hq/client';
+export { getArciumProgramReadonly, getArxNodeAcc, getClockAcc, getClusterAcc, getCompDefAcc, getComputationAcc, getExecutingPoolAcc, getMXEAccAcc, getMempoolAcc, getStakingPoolAcc } from '@arcium-hq/client';
+import * as anchor from '@coral-xyz/anchor';
+
+const ARCIUM_PROGRAM_ID_STRING = 'BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6';
+const ARX_NODE_ACC_DISCRIMINATOR = [2, 207, 122, 223, 93, 97, 231, 199];
+const CLUSTER_ACC_DISCRIMINATOR = [236, 225, 118, 228, 173, 106, 18, 60];
+const MXE_ACC_DISCRIMINATOR = [32, 115, 16, 240, 209, 25, 92, 165];
+const ARCIUM_PROGRAM_ID = new anchor.web3.PublicKey(ARCIUM_PROGRAM_ID_STRING);
+new anchor.BorshInstructionCoder(ARCIUM_IDL);
+const ARCIUM_EVENT_CODER = new anchor.EventParser(ARCIUM_PROGRAM_ID, new anchor.BorshCoder(ARCIUM_IDL));
+
+// Returns all MXE accounts
+async function getMXEAccs(conn) {
+    return getArciumAccPubkeys(conn, MXE_ACC_DISCRIMINATOR);
+}
+// Returns all Cluster accounts
+async function getClusterAccs(conn) {
+    return getArciumAccPubkeys(conn, CLUSTER_ACC_DISCRIMINATOR);
+}
+// Returns all ArxNode accounts
+async function getArxNodeAccs(conn) {
+    return getArciumAccPubkeys(conn, ARX_NODE_ACC_DISCRIMINATOR);
+}
+// Fetches and parses a given MXE account. Format:
+async function getMXEAccInfo(arciumProgram, address, commitment) {
+    return arciumProgram.account.persistentMxeAccount.fetch(address, commitment);
+}
+async function getClusterAccInfo(arciumProgram, address, commitment) {
+    return arciumProgram.account.cluster.fetch(address, commitment);
+}
+async function getArxNodeAccInfo(arciumProgram, address, commitment) {
+    return arciumProgram.account.arxNode.fetch(address, commitment);
+}
+async function getComputationsInMempool(arciumProgram, address) {
+    const mempool = await getMempoolAccData(arciumProgram.provider, address);
+    const startIndex = mempool.inner.computations.startIndex;
+    const length = mempool.inner.computations.length;
+    const elems = mempool.inner.computations.elems;
+    function isValid(validBits, idx) {
+        const byte = idx >>> 3;
+        const bit = idx & 7;
+        if (byte >= validBits.length) {
+            // This should never happen, so we'll want to know about it
+            throw new Error(`isValid: byte ${byte} >= validBits.length ${validBits.length}`);
+        }
+        return (validBits[byte] & (1 << bit)) !== 0;
+    }
+    // Handle circular buffer wraparound
+    const refs = [];
+    for (let i = 0; i < length; i++) {
+        const idx = (startIndex + i) % elems.length;
+        // Only save non-stake computations
+        if (isValid(mempool.inner.computations.validBits, idx)) {
+            refs.push(...elems[idx].entries);
+        }
+    }
+    return refs.flat().filter((ref) => !isNullRef(ref));
+}
+async function getComputation(arciumProgram, address, commitment) {
+    return arciumProgram.account.computationAccount.fetch(address, commitment);
+}
+async function getArciumAccPubkeys(conn, discriminator) {
+    const accs = await conn.getProgramAccounts(ARCIUM_PROGRAM_ID, {
+        dataSlice: { offset: 0, length: 0 },
+        filters: [{
+                memcmp: {
+                    offset: 0,
+                    encoding: 'base64',
+                    bytes: Buffer.from(discriminator).toString('base64'),
+                },
+            }],
+    });
+    return accs.map((acc) => acc.pubkey);
+}
+function isNullRef(ref) {
+    const bigZero = new anchor.BN(0);
+    return ref.computationDefinitionOffset === 0 && ref.computationOffset === bigZero && ref.priorityFee === bigZero;
+}
+
+const ArciumEventNames = [
+    'QueueComputationEvent',
+    'InitComputationEvent',
+    'CallbackComputationEvent',
+    'FinalizeComputationEvent',
+];
+async function subscribeComputations(conn, mxeProgramId, callback) {
+    return conn.onLogs(mxeProgramId, (logs) => {
+        const events = getComputationEventsFromLogs(logs.logs);
+        for (const event of events) {
+            callback(event.event, event.name);
+        }
+    });
+}
+async function unsubscribeComputations(conn, subscriptionId) {
+    conn.removeOnLogsListener(subscriptionId);
+}
+/**
+ * Get the computation offset from a transaction
+ * @param tx - The transaction to get the computation offset from
+ * @returns The computation offset if one is found, otherwise null.
+ * @throws Error if multiple computation offsets are found in the transaction
+ */
+function getComputationOffset(tx) {
+    const events = getComputationEventsFromLogs(tx.meta?.logMessages ?? []);
+    if (events.length === 0) {
+        return undefined;
+    }
+    const computationOffsets = events.map((e) => e.event.computationOffset);
+    const computationOffset = computationOffsets[0];
+    if (computationOffsets.some((offset) => offset !== computationOffset)) {
+        throw new Error(`Multiple computation offsets found in computation: ${JSON.stringify(computationOffsets)}`);
+    }
+    return computationOffset;
+}
+/**
+ * Get the events related to arcium computations from a transaction's logs
+ * @param logs - The logs to get the events from
+ * @returns The events in the logs.
+ */
+function getComputationEventsFromLogs(logs) {
+    return Array.from(ARCIUM_EVENT_CODER.parseLogs(logs))
+        .filter((e) => ArciumEventNames.includes(e.name))
+        .map((e) => ({
+        event: e.data,
+        name: e.name,
+    }));
+}
+
+export { getArxNodeAccInfo, getArxNodeAccs, getClusterAccInfo, getClusterAccs, getComputation, getComputationOffset, getComputationsInMempool, getMXEAccInfo, getMXEAccs, subscribeComputations, unsubscribeComputations };

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@arcium-hq/reader",
+  "version": "0.1.45",
+  "description": "Reader SDK for fetching onchain data for Arcium network programs",
+  "author": "Arcium",
+  "license": "GPL-3.0-only",
+  "main": "build/index.mjs",
+  "scripts": {
+    "test": "mocha test/**/*.ts --exit",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" \"test/**/*.ts\" --fix",
+    "lint:clean": "rm -rf dist/ && rm -rf build/",
+    "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",
+    "test-single": "mocha $1 --exit"
+  },
+  "type": "module",
+  "module": "build/index.mjs",
+  "types": "build/index.d.ts",
+  "files": [
+    "build/index.cjs",
+    "build/index.mjs",
+    "build/index.d.ts"
+  ],
+  "exports": [
+    {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.mjs",
+      "require": "./build/index.cjs"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arcium-hq/arcium-tooling.git"
+  },
+  "devDependencies": {
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-typescript": "^12.1.1",
+    "@types/bn.js": "^5.1.6",
+    "@types/chai": "^5.0.0",
+    "@types/mocha": "^10.0.9",
+    "@types/snarkjs": "^0.7.8",
+    "@typescript-eslint/eslint-plugin": "6.12.0",
+    "@typescript-eslint/parser": "6.12.0",
+    "chai": "^5.1.2",
+    "eslint": "8.54.0",
+    "eslint-config-airbnb-base": "15.0.0",
+    "eslint-plugin-import": "2.29.0",
+    "mocha": "^10.8.2",
+    "rollup": "^4.24.0",
+    "rollup-plugin-dts": "^6.1.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^4.5.2"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.31.1",
+    "@noble/curves": "^1.8.1",
+    "@noble/hashes": "^1.7.1",
+    "@arcium-hq/client": "0.1.45"
+  },
+  "keywords": [
+    "Cryptography",
+    "Privacy",
+    "Multiparty Computation",
+    "Arcium",
+    "Blockchain",
+    "Solana",
+    "Confidential Computing",
+    "MPC"
+  ]
+}