prividium 0.15.1 → 0.16.0

package/dist/sdk/create-prividium-client.js

@@ -1,4 +1,5 @@
 import { createClient, publicActions } from 'viem';
+import { selectiveDisclosureActions } from './selective-disclosure/actions';
 function prividiumActions(client) {
     return {
         call: (args) => {
@@ -21,5 +22,5 @@ export function createPrividiumClient(config) {
         name,
         type: 'publicClient'
     });
-    return client.extend(publicActions).extend(prividiumActions);
+    return client.extend(publicActions).extend(prividiumActions).extend(selectiveDisclosureActions);
 }

package/dist/sdk/index.d.ts

@@ -2,6 +2,7 @@ export { createPrividiumClient } from './create-prividium-client.js';
 export { type AuthCallbackMessage, handleAuthCallback, type OauthScope, PopupAuth } from './popup-auth.js';
 export { createPrividiumChain } from './prividium-chain.js';
 export { FORBIDDEN_ERROR_CODE, UNAUTHORIZED_ERROR_CODE } from './rpc-error-codes.js';
+export * from './selective-disclosure/index.js';
 export { LocalStorage, TokenManager } from './storage.js';
 export { generateRandomState } from './token-utils.js';
 export type { AddNetworkParams, ContractAbiResponse, PopupOptions, PrividiumChain, PrividiumConfig, Storage, TokenData, UserProfile, UserRole } from './types.js';

package/dist/sdk/index.js

@@ -2,6 +2,7 @@ export { createPrividiumClient } from './create-prividium-client.js';
 export { handleAuthCallback, PopupAuth } from './popup-auth.js';
 export { createPrividiumChain } from './prividium-chain.js';
 export { FORBIDDEN_ERROR_CODE, UNAUTHORIZED_ERROR_CODE } from './rpc-error-codes.js';
+export * from './selective-disclosure/index.js';
 export { LocalStorage, TokenManager } from './storage.js';
 export { generateRandomState } from './token-utils.js';
 export { AUTH_ERRORS, STORAGE_KEYS } from './types.js';

package/dist/sdk/selective-disclosure/actions.d.ts

@@ -0,0 +1,11 @@
+import { type Account, type Address, type Chain, type Client, type RpcSchema, type Transport } from 'viem';
+import type { EthCallDisclosureResult } from './disclosure-result';
+export type SelectiveDisclosureActions = {
+    tokenSupplyDisclosure: (tokenAddress: Address, blockNumber: number | bigint) => Promise<EthCallDisclosureResult>;
+    tokenBalanceDisclosure: (tokenAddress: Address, holderAddress: Address, blockNumber: number | bigint) => Promise<EthCallDisclosureResult>;
+};
+/**
+ * Viem action extender that adds Prividium selective-disclosure RPC methods
+ * to a client. Use with `client.extend(selectiveDisclosureActions)`.
+ */
+export declare function selectiveDisclosureActions<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, accountOrAddress extends Account | undefined = undefined, rpcSchema extends RpcSchema | undefined = undefined>(client: Client<transport, chain, accountOrAddress, rpcSchema>): SelectiveDisclosureActions;

package/dist/sdk/selective-disclosure/actions.js

@@ -0,0 +1,21 @@
+import { numberToHex } from 'viem';
+/**
+ * Viem action extender that adds Prividium selective-disclosure RPC methods
+ * to a client. Use with `client.extend(selectiveDisclosureActions)`.
+ */
+export function selectiveDisclosureActions(client) {
+    return {
+        async tokenSupplyDisclosure(tokenAddress, blockNumber) {
+            return client.request({
+                method: 'prividium_tokenSupplyDisclosure',
+                params: [tokenAddress, numberToHex(blockNumber)]
+            });
+        },
+        async tokenBalanceDisclosure(tokenAddress, holderAddress, blockNumber) {
+            return client.request({
+                method: 'prividium_tokenBalanceDisclosure',
+                params: [tokenAddress, holderAddress, numberToHex(blockNumber)]
+            });
+        }
+    };
+}

package/dist/sdk/selective-disclosure/batch-info.d.ts

@@ -0,0 +1,2 @@
+import { type Hex } from 'viem';
+export declare function encodeBatchInfo(batchNumber: bigint, stateCommitment: Hex, numberOfLayer1Txs: bigint, priorityOperationsHash: Hex, l2ToL1LogsRootHash: Hex, commitment: Hex): Hex;

package/dist/sdk/selective-disclosure/batch-info.js

@@ -0,0 +1,14 @@
+import { encodeAbiParameters, pad, parseAbiParameters } from 'viem';
+export function encodeBatchInfo(batchNumber, stateCommitment, numberOfLayer1Txs, priorityOperationsHash, l2ToL1LogsRootHash, commitment) {
+    return encodeAbiParameters(parseAbiParameters('uint64, bytes32, uint64, uint256, bytes32, bytes32, bytes32, uint256, bytes32'), [
+        batchNumber,
+        stateCommitment,
+        0n, // indexRepeatedStorageChanges
+        numberOfLayer1Txs,
+        priorityOperationsHash,
+        pad('0x00'), // dependencyRootsRollingHash
+        l2ToL1LogsRootHash,
+        0n, // timestamp
+        commitment
+    ]);
+}

package/dist/sdk/selective-disclosure/disclosure-result.d.ts

@@ -0,0 +1,36 @@
+import type { Hex } from 'viem';
+import type { StorageSlotProof } from './verifiy-proofs';
+export type StateCommitmentPreimage = {
+    nextFreeSlot: Hex;
+    blockNumber: Hex;
+    last256BlockHashesBlake: Hex;
+    lastBlockTimestamp: Hex;
+};
+export type L1VerificationData = {
+    batchNumber: number;
+    numberOfLayer1Txs: number;
+    priorityOperationsHash: Hex;
+    dependencyRootsRollingHash: Hex;
+    l2ToL1LogsRootHash: Hex;
+    commitment: Hex;
+};
+export type StorageProof = {
+    key: Hex;
+    proof: StorageSlotProof;
+};
+export type AccountStorageProofs = {
+    address: Hex;
+    storageProofs: StorageProof[];
+};
+/**
+ * Shared response shape returned by all token-related selective-disclosure
+ * RPC methods (`prividium_tokenSupplyDisclosure`, `prividium_tokenBalanceDisclosure`).
+ */
+export type EthCallDisclosureResult = {
+    result: Hex;
+    callData: Hex;
+    batchNumber: number;
+    stateCommitmentPreimage: StateCommitmentPreimage;
+    l1VerificationData: L1VerificationData;
+    proofs: AccountStorageProofs[];
+};

package/dist/sdk/selective-disclosure/disclosure-result.js

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

package/dist/sdk/selective-disclosure/index.d.ts

@@ -0,0 +1,8 @@
+export * from './actions';
+export * from './batch-info';
+export * from './disclosure-result';
+export * from './state-commitment';
+export * from './token-balance-disclosure';
+export * from './token-supply-disclosure';
+export * from './verifiy-proofs';
+export * from './verify-disclosure';

package/dist/sdk/selective-disclosure/index.js

@@ -0,0 +1,8 @@
+export * from './actions';
+export * from './batch-info';
+export * from './disclosure-result';
+export * from './state-commitment';
+export * from './token-balance-disclosure';
+export * from './token-supply-disclosure';
+export * from './verifiy-proofs';
+export * from './verify-disclosure';

package/dist/sdk/selective-disclosure/state-commitment.d.ts

@@ -0,0 +1,2 @@
+import { type Hex } from 'viem';
+export declare function computeStateCommitment(treeRoot: Hex, nextFreeSlot: bigint, blockNumber: bigint, last256BlockHashesBlake: Hex, lastBlockTimestamp: bigint): Hex;

package/dist/sdk/selective-disclosure/state-commitment.js

@@ -0,0 +1,12 @@
+import { bytesToHex, hexToBytes } from 'viem';
+import { blake2s256, concatBytes } from './utils';
+export function computeStateCommitment(treeRoot, nextFreeSlot, blockNumber, last256BlockHashesBlake, lastBlockTimestamp) {
+    const nextFreeSlotBytes = new Uint8Array(8);
+    new DataView(nextFreeSlotBytes.buffer).setBigUint64(0, nextFreeSlot, false); // big-endian
+    const blockNumberBytes = new Uint8Array(8);
+    new DataView(blockNumberBytes.buffer).setBigUint64(0, blockNumber, false);
+    const timestampBytes = new Uint8Array(8);
+    new DataView(timestampBytes.buffer).setBigUint64(0, lastBlockTimestamp, false);
+    const bytes = blake2s256(concatBytes(hexToBytes(treeRoot), nextFreeSlotBytes, blockNumberBytes, hexToBytes(last256BlockHashesBlake), timestampBytes));
+    return bytesToHex(bytes);
+}

package/dist/sdk/selective-disclosure/token-balance-disclosure.d.ts

@@ -0,0 +1,7 @@
+import type { Address, Hex } from 'viem';
+import type { EthCallDisclosureResult } from './disclosure-result';
+export type TokenBalanceDisclosureRpc = {
+    Method: 'prividium_tokenBalanceDisclosure';
+    Parameters: [tokenAddress: Address, holderAddress: Address, blockNumber: Hex];
+    ReturnType: EthCallDisclosureResult;
+};

package/dist/sdk/selective-disclosure/token-balance-disclosure.js

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

package/dist/sdk/selective-disclosure/token-supply-disclosure.d.ts

@@ -0,0 +1,7 @@
+import type { Address, Hex } from 'viem';
+import type { EthCallDisclosureResult } from './disclosure-result';
+export type TokenSupplyDisclosureRpc = {
+    Method: 'prividium_tokenSupplyDisclosure';
+    Parameters: [tokenAddress: Address, blockNumber: Hex];
+    ReturnType: EthCallDisclosureResult;
+};

package/dist/sdk/selective-disclosure/token-supply-disclosure.js

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

package/dist/sdk/selective-disclosure/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+export declare function blake2s256(data: Uint8Array): Uint8Array;

package/dist/sdk/selective-disclosure/utils.js

@@ -0,0 +1,14 @@
+import { blake2s } from 'blakejs';
+export function concatBytes(...arrays) {
+    const totalSize = arrays.map((bytes) => bytes.length).reduce((a, b) => a + b);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+export function blake2s256(data) {
+    return blake2s(data, undefined, 32);
+}

package/dist/sdk/selective-disclosure/verifiy-proofs.d.ts

@@ -0,0 +1,31 @@
+import { type Hex } from 'viem';
+export type StorageRoot = {
+    treeRoot: Hex;
+    value: Hex | null;
+};
+export interface ExistenceProof {
+    type: 'existing';
+    index: number;
+    value: Hex;
+    nextIndex: number;
+    siblings: Hex[];
+}
+export interface NonExistenceProof {
+    type: 'nonExisting';
+    leftNeighbor: {
+        index: number;
+        leafKey: Hex;
+        value: Hex;
+        nextIndex: number;
+        siblings: Hex[];
+    };
+    rightNeighbor: {
+        index: number;
+        leafKey: Hex;
+        value: Hex;
+        nextIndex: number;
+        siblings: Hex[];
+    };
+}
+export type StorageSlotProof = ExistenceProof | NonExistenceProof;
+export declare function calculateStateMerkleRoot(proof: StorageSlotProof, address: Hex, storageSlot: Hex): StorageRoot;

package/dist/sdk/selective-disclosure/verifiy-proofs.js

@@ -0,0 +1,85 @@
+import { bytesToHex, hexToBytes, pad } from 'viem';
+import { blake2s256, concatBytes } from './utils';
+function deriveFlatKey(address, storageKey) {
+    // blake2s(pad32(address) || storageKey)
+    const addressBytes = hexToBytes(pad(address));
+    const keyBytes = hexToBytes(storageKey);
+    return blake2s256(concatBytes(addressBytes, keyBytes));
+}
+function hashLeaf(leafKey, value, nextIndex) {
+    // blake2s(leafKey || value || nextIndex.to_le_bytes(8))
+    const nextIndexBytes = new Uint8Array(8);
+    const view = new DataView(nextIndexBytes.buffer);
+    view.setBigUint64(0, nextIndex, true); // little-endian
+    return blake2s256(concatBytes(leafKey, value, nextIndexBytes));
+}
+const TREE_DEPTH = 64;
+function computeEmptyHashes() {
+    const hashes = new Array(TREE_DEPTH);
+    // emptyHash[0] = blake2s(0x00{72}) — empty leaf (key=0, value=0, next=0)
+    hashes[0] = blake2s256(new Uint8Array(72));
+    for (let i = 1; i < TREE_DEPTH; i++) {
+        hashes[i] = blake2s256(concatBytes(hashes[i - 1], hashes[i - 1]));
+    }
+    return hashes;
+}
+const EMPTY_HASHES = computeEmptyHashes();
+function walkMerklePath(leafHash, index, siblings) {
+    // Pad siblings with empty hashes if shorter than TREE_DEPTH
+    const fullPath = [...siblings];
+    for (let i = siblings.length; i < TREE_DEPTH; i++) {
+        fullPath.push(EMPTY_HASHES[i]);
+    }
+    let current = leafHash;
+    let idx = index;
+    for (let i = 0; i < TREE_DEPTH; i++) {
+        const sibling = fullPath[i];
+        if (idx % 2n === 0n) {
+            current = blake2s256(concatBytes(current, sibling));
+        }
+        else {
+            current = blake2s256(concatBytes(sibling, current));
+        }
+        idx = idx / 2n;
+    }
+    if (idx !== 0n) {
+        throw new Error(`Merkle path walk did not reach root: remaining index = ${idx}`);
+    }
+    return current;
+}
+export function calculateStateMerkleRoot(proof, address, storageSlot) {
+    if (proof.type === 'existing') {
+        const existenceProof = proof;
+        const flatKey = deriveFlatKey(address, storageSlot);
+        const siblings = existenceProof.siblings.map((s) => hexToBytes(s));
+        const leaf = hashLeaf(flatKey, hexToBytes(existenceProof.value), BigInt(existenceProof.nextIndex));
+        const root = walkMerklePath(leaf, BigInt(existenceProof.index), siblings);
+        return { treeRoot: bytesToHex(root), value: existenceProof.value };
+    }
+    else {
+        const nonExistenceProof = proof;
+        const flatKey = deriveFlatKey(address, storageSlot);
+        const leftSiblings = nonExistenceProof.leftNeighbor.siblings.map((s) => hexToBytes(s));
+        const leftLeaf = hashLeaf(hexToBytes(nonExistenceProof.leftNeighbor.leafKey), hexToBytes(nonExistenceProof.leftNeighbor.value), BigInt(nonExistenceProof.leftNeighbor.nextIndex));
+        const leftRoot = walkMerklePath(leftLeaf, BigInt(nonExistenceProof.leftNeighbor.index), leftSiblings);
+        const rightSiblings = nonExistenceProof.rightNeighbor.siblings.map((s) => hexToBytes(s));
+        const rightLeaf = hashLeaf(hexToBytes(nonExistenceProof.rightNeighbor.leafKey), hexToBytes(nonExistenceProof.rightNeighbor.value), BigInt(nonExistenceProof.rightNeighbor.nextIndex));
+        const rightRoot = walkMerklePath(rightLeaf, BigInt(nonExistenceProof.rightNeighbor.index), rightSiblings);
+        // Both neighbors must agree on the tree root
+        if (bytesToHex(leftRoot) !== bytesToHex(rightRoot)) {
+            throw new Error('Non-existing proof: left and right neighbors disagree on tree root');
+        }
+        // Verify the queried key falls between the neighbors
+        const flatKeyHex = bytesToHex(flatKey);
+        const leftKeyHex = nonExistenceProof.leftNeighbor.leafKey.toLowerCase();
+        const rightKeyHex = nonExistenceProof.rightNeighbor.leafKey.toLowerCase();
+        if (flatKeyHex <= leftKeyHex || flatKeyHex >= rightKeyHex) {
+            throw new Error(`Non-existing proof: flat key ${flatKeyHex} not between left ${leftKeyHex} and right ${rightKeyHex}`);
+        }
+        // Verify linked list continuity
+        if (nonExistenceProof.leftNeighbor.nextIndex !== nonExistenceProof.rightNeighbor.index) {
+            throw new Error(`Non-existing proof: left.nextIndex (${nonExistenceProof.leftNeighbor.nextIndex}) != right.index (${nonExistenceProof.rightNeighbor.index})`);
+        }
+        return { treeRoot: bytesToHex(leftRoot), value: null };
+    }
+}

package/dist/sdk/selective-disclosure/verify-disclosure.d.ts

@@ -0,0 +1,28 @@
+import { type Address, type Hex, type PublicClient } from 'viem';
+import type { EthCallDisclosureResult } from './disclosure-result';
+/**
+ * Verifies an ethCall disclosure response end-to-end.
+ *
+ * Verification steps:
+ * 1. Extracts Merkle roots from all storage proofs and checks they are consistent.
+ * 2. Computes the state commitment from the tree root and preimage data.
+ * 3. Encodes the batch info, hashes it, and compares against the L1 diamond proxy's `storedBatchHash`.
+ * 4. Replays the original call on `l2Client` with state overrides (proven storage + bytecodes)
+ *    and checks the result matches the disclosed value.
+ *
+ * Throws if the disclosure data is internally inconsistent (e.g. no proofs, divergent roots,
+ * or missing bytecode for a contract referenced in the proofs).
+ *
+ * Returns `true` if every check passes, `false` otherwise.
+ *
+ * @param disclosure - The response from `prividium_tokenSupplyDisclosure` or `prividium_tokenBalanceDisclosure`.
+ * @param l1Client - A viem PublicClient connected to L1, used to read `storedBatchHash` from the diamond proxy.
+ * @param l2Client - A viem PublicClient connected to a local L2 node trusted by the caller. Used to
+ *   replay the disclosed call with state overrides. This must be a node the caller trusts, not the
+ *   Prividium proxy, so the replay cannot be manipulated.
+ * @param diamondAddress - The address of the L1 diamond proxy contract that stores batch commitments.
+ * @param contractBytecodes - A mapping from contract address to deployed bytecode (hex) for every
+ *   contract referenced in the disclosure proofs. Used for the call replay with state overrides.
+ * @param batchNumber - The L1 batch number the disclosure was computed against.
+ */
+export declare function verifyEthCallDisclosure(disclosure: EthCallDisclosureResult, l1Client: PublicClient, l2Client: PublicClient, diamondAddress: Address, contractBytecodes: Record<Address, Hex>, batchNumber: number): Promise<boolean>;

package/dist/sdk/selective-disclosure/verify-disclosure.js

@@ -0,0 +1,88 @@
+import { keccak256, pad, parseAbiItem } from 'viem';
+import { encodeBatchInfo } from './batch-info';
+import { computeStateCommitment } from './state-commitment';
+import { calculateStateMerkleRoot } from './verifiy-proofs';
+const diamondAbi = [parseAbiItem('function storedBatchHash(uint256 _batchNumber) external view returns (bytes32)')];
+/**
+ * Verifies an ethCall disclosure response end-to-end.
+ *
+ * Verification steps:
+ * 1. Extracts Merkle roots from all storage proofs and checks they are consistent.
+ * 2. Computes the state commitment from the tree root and preimage data.
+ * 3. Encodes the batch info, hashes it, and compares against the L1 diamond proxy's `storedBatchHash`.
+ * 4. Replays the original call on `l2Client` with state overrides (proven storage + bytecodes)
+ *    and checks the result matches the disclosed value.
+ *
+ * Throws if the disclosure data is internally inconsistent (e.g. no proofs, divergent roots,
+ * or missing bytecode for a contract referenced in the proofs).
+ *
+ * Returns `true` if every check passes, `false` otherwise.
+ *
+ * @param disclosure - The response from `prividium_tokenSupplyDisclosure` or `prividium_tokenBalanceDisclosure`.
+ * @param l1Client - A viem PublicClient connected to L1, used to read `storedBatchHash` from the diamond proxy.
+ * @param l2Client - A viem PublicClient connected to a local L2 node trusted by the caller. Used to
+ *   replay the disclosed call with state overrides. This must be a node the caller trusts, not the
+ *   Prividium proxy, so the replay cannot be manipulated.
+ * @param diamondAddress - The address of the L1 diamond proxy contract that stores batch commitments.
+ * @param contractBytecodes - A mapping from contract address to deployed bytecode (hex) for every
+ *   contract referenced in the disclosure proofs. Used for the call replay with state overrides.
+ * @param batchNumber - The L1 batch number the disclosure was computed against.
+ */
+export async function verifyEthCallDisclosure(disclosure, l1Client, l2Client, diamondAddress, contractBytecodes, batchNumber) {
+    // Step 1: Extract Merkle roots from all storage proofs and verify they're consistent.
+    const roots = [];
+    for (const proof of disclosure.proofs) {
+        for (const storageProof of proof.storageProofs) {
+            const { treeRoot } = calculateStateMerkleRoot(storageProof.proof, proof.address, storageProof.key);
+            roots.push(treeRoot);
+        }
+    }
+    if (roots.length === 0) {
+        throw new Error('Inconsistent data: no proofs');
+    }
+    if (new Set(roots).size !== 1) {
+        throw new Error('Inconsistent data: multiple roots for same batch');
+    }
+    // Step 2: Compute state commitment from the tree root + preimage data.
+    const stateCommitment = computeStateCommitment(roots[0], BigInt(disclosure.stateCommitmentPreimage.nextFreeSlot), BigInt(disclosure.stateCommitmentPreimage.blockNumber), disclosure.stateCommitmentPreimage.last256BlockHashesBlake, BigInt(disclosure.stateCommitmentPreimage.lastBlockTimestamp));
+    // Step 3: Encode batch info and keccak256 hash it.
+    const batchInfoHex = encodeBatchInfo(BigInt(batchNumber), stateCommitment, BigInt(disclosure.l1VerificationData.numberOfLayer1Txs), disclosure.l1VerificationData.priorityOperationsHash, disclosure.l1VerificationData.l2ToL1LogsRootHash, disclosure.l1VerificationData.commitment);
+    const batchInfoHash = keccak256(batchInfoHex);
+    // Step 4: Verify against L1 diamond proxy.
+    const storedBatchHash = await l1Client.readContract({
+        address: diamondAddress,
+        abi: diamondAbi,
+        functionName: 'storedBatchHash',
+        args: [BigInt(batchNumber)]
+    });
+    if (batchInfoHash !== storedBatchHash) {
+        return false;
+    }
+    // Step 5: Replay the call on L2 with state overrides to verify the proven
+    // storage values produce the expected result.
+    const contractAddress = disclosure.proofs[0].address;
+    const stateOverride = disclosure.proofs.map((proof) => {
+        const address = proof.address.toLowerCase();
+        const code = contractBytecodes[address];
+        if (!code) {
+            throw new Error(`Missing bytecode for contract ${address}`);
+        }
+        return {
+            address,
+            code,
+            state: proof.storageProofs.map((sp) => ({
+                slot: sp.key,
+                value: sp.proof.type === 'existing' ? sp.proof.value : pad('0x0')
+            }))
+        };
+    });
+    const callResult = await l2Client.call({
+        to: contractAddress,
+        data: disclosure.callData,
+        stateOverride
+    });
+    if (!callResult.data) {
+        return false;
+    }
+    return BigInt(callResult.data) === BigInt(disclosure.result);
+}

package/dist/tsconfig.sdk.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/chain-core.ts","../src/create-prividium-client.ts","../src/error-utils.ts","../src/errors.ts","../src/index.ts","../src/memory-storage.ts","../src/popup-auth.ts","../src/prividium-chain.ts","../src/rpc-error-codes.ts","../src/siwe-auth.ts","../src/siwe-chain.ts","../src/siwe.ts","../src/storage.ts","../src/test-utils.ts","../src/token-utils.ts","../src/types.ts"],"version":"5.8.3"}
+{"root":["../src/chain-core.ts","../src/create-prividium-client.ts","../src/error-utils.ts","../src/errors.ts","../src/index.ts","../src/memory-storage.ts","../src/popup-auth.ts","../src/prividium-chain.ts","../src/rpc-error-codes.ts","../src/siwe-auth.ts","../src/siwe-chain.ts","../src/siwe.ts","../src/storage.ts","../src/test-utils.ts","../src/token-utils.ts","../src/types.ts","../src/selective-disclosure/actions.ts","../src/selective-disclosure/batch-info.ts","../src/selective-disclosure/disclosure-result.ts","../src/selective-disclosure/index.ts","../src/selective-disclosure/state-commitment.ts","../src/selective-disclosure/token-balance-disclosure.ts","../src/selective-disclosure/token-supply-disclosure.ts","../src/selective-disclosure/utils.ts","../src/selective-disclosure/verifiy-proofs.ts","../src/selective-disclosure/verify-disclosure.ts"],"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prividium",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "type": "module",
   "bin": {
     "prividium": "bin/cli.js"
@@ -37,6 +37,7 @@
     "@fastify/http-proxy": "^11.3.0",
     "@fastify/static": "^9.0.0",
     "appdirsjs": "^1.2.7",
+    "blakejs": "^1.2.1",
     "date-fns": "^4.1.0",
     "fastify": "^5.7.2",
     "fastify-type-provider-zod": "^6.1.0",