prividium 0.15.1 → 0.17.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/account-properties.d.ts

@@ -0,0 +1,12 @@
+import { type Address, type Hex, type PublicClient } from 'viem';
+import type { AccountDataDisclosureResult, AccountProperties } from './disclosure-result';
+export declare function encodeAccountProperties(params: AccountProperties): Hex;
+/**
+ * Compute the internal bytecode hash: blake2s(code || padding || artifacts)
+ * Returns { bytecodeHash, artifactsLen }
+ */
+export declare function computeInternalBytecodeHash(codeHex: Hex): {
+    bytecodeHash: Hex;
+    artifactsLen: number;
+};
+export declare function verifyAccountPropertiesProof(disclosure: AccountDataDisclosureResult, l1Client: PublicClient, diamondAddress: Address, expectedBytecode?: Hex): Promise<boolean>;

package/dist/sdk/selective-disclosure/account-properties.js

@@ -0,0 +1,113 @@
+import { bytesToHex, hexToBigInt, hexToBytes, keccak256, pad } from 'viem';
+import { encodeBatchInfo } from './batch-info';
+import { computeStateCommitment } from './state-commitment';
+import { blake2s256 } from './utils';
+import { calculateStateMerkleRoot } from './verifiy-proofs';
+import { DIAMOND_ABI } from './verify-disclosure';
+const PUSH1 = 0x60;
+const PUSH32 = 0x7f;
+const JUMPDEST = 0x5b;
+const BYTECODE_ALIGNMENT = 8;
+export function encodeAccountProperties(params) {
+    const buf = new Uint8Array(124);
+    const view = new DataView(buf.buffer);
+    view.setBigUint64(0, hexToBigInt(params.versioningData), false);
+    view.setBigUint64(8, hexToBigInt(params.nonce), false);
+    // Balance as 32 bytes big-endian
+    const balanceHex = hexToBigInt(params.balance).toString(16).padStart(64, '0');
+    for (let i = 0; i < 32; i++) {
+        buf[16 + i] = parseInt(balanceHex.slice(i * 2, i * 2 + 2), 16);
+    }
+    buf.set(hexToBytes(params.bytecodeHash), 48);
+    view.setUint32(80, params.unpaddedCodeLen, false);
+    view.setUint32(84, params.artifactsLen, false);
+    buf.set(hexToBytes(params.observableBytecodeHash), 88);
+    view.setUint32(120, params.observableBytecodeLen, false);
+    return bytesToHex(buf);
+}
+/**
+ * Compute the internal bytecode hash: blake2s(code || padding || artifacts)
+ * Returns { bytecodeHash, artifactsLen }
+ */
+export function computeInternalBytecodeHash(codeHex) {
+    const code = hexToBytes(codeHex);
+    const paddingLen = computeBytecodePaddingLen(code.length);
+    const artifacts = computeJumpdestBitmap(code);
+    const fullLen = code.length + paddingLen + artifacts.length;
+    const buf = new Uint8Array(fullLen); // zero-initialized (padding is zeros)
+    buf.set(code, 0);
+    buf.set(artifacts, code.length + paddingLen);
+    return {
+        bytecodeHash: bytesToHex(blake2s256(buf)),
+        artifactsLen: artifacts.length
+    };
+}
+const ACCOUNT_PROPERTIES_ADDRESS = '0x0000000000000000000000000000000000008003';
+export async function verifyAccountPropertiesProof(disclosure, l1Client, diamondAddress, expectedBytecode) {
+    const isEoa = BigInt(disclosure.accountProperties.bytecodeHash) === 0n;
+    if (isEoa && expectedBytecode !== undefined && BigInt(expectedBytecode) !== 0n) {
+        return false;
+    }
+    if (!isEoa) {
+        if (expectedBytecode === undefined) {
+            return false;
+        }
+        const { bytecodeHash: computedHash } = computeInternalBytecodeHash(expectedBytecode);
+        if (computedHash.toLowerCase() !== disclosure.accountProperties.bytecodeHash.toLowerCase()) {
+            return false;
+        }
+    }
+    const { treeRoot, value: propertiesHash } = calculateStateMerkleRoot(disclosure.storageProof, ACCOUNT_PROPERTIES_ADDRESS, pad(disclosure.address));
+    const encodedProperties = encodeAccountProperties(disclosure.accountProperties);
+    const reconstructedHash = blake2s256(hexToBytes(encodedProperties));
+    if (bytesToHex(reconstructedHash).toLowerCase() !== propertiesHash?.toLowerCase()) {
+        return false;
+    }
+    // Step 2: Compute state commitment from the tree root + preimage data.
+    const stateCommitment = computeStateCommitment(treeRoot, BigInt(disclosure.stateCommitmentPreimage.nextFreeSlot), BigInt(disclosure.stateCommitmentPreimage.blockNumber), disclosure.stateCommitmentPreimage.last256BlockHashesBlake, BigInt(disclosure.stateCommitmentPreimage.lastBlockTimestamp));
+    const batchInfoHex = encodeBatchInfo(BigInt(disclosure.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: DIAMOND_ABI,
+        functionName: 'storedBatchHash',
+        args: [BigInt(disclosure.batchNumber)]
+    });
+    return batchInfoHash.toLowerCase() === storedBatchHash.toLowerCase();
+}
+/**
+ * Build the JUMPDEST bitmap matching the ZKsync OS evm_interpreter `analyze()`.
+ * The bitmap is stored as u64 words in little-endian byte order.
+ */
+function computeJumpdestBitmap(code) {
+    // Number of u64 words needed: ceil(code.length / 64)
+    const u64Count = Math.ceil(code.length / 64) || 0;
+    const bitmap = new Uint8Array(u64Count * 8); // zero-initialized
+    let i = 0;
+    while (i < code.length) {
+        const op = code[i];
+        if (op === JUMPDEST) {
+            // Set bit at position i in the little-endian u64 bitmap.
+            // Word index (in u64 terms): Math.floor(i / 64)
+            // Bit within that u64: i % 64
+            // Byte within that u64 (little-endian): Math.floor((i % 64) / 8)
+            // Bit within that byte: (i % 64) % 8
+            const byteIndex = Math.floor(i / 64) * 8 + Math.floor((i % 64) / 8);
+            const bitIndex = (i % 64) % 8;
+            bitmap[byteIndex] |= 1 << bitIndex;
+            i += 1;
+        }
+        else if (op >= PUSH1 && op <= PUSH32) {
+            i += 1 + (op - PUSH1 + 1);
+        }
+        else {
+            i += 1;
+        }
+    }
+    return bitmap;
+}
+function computeBytecodePaddingLen(codeLen) {
+    const rem = codeLen % BYTECODE_ALIGNMENT;
+    return rem === 0 ? 0 : BYTECODE_ALIGNMENT - rem;
+}

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

@@ -0,0 +1,28 @@
+import { type Account, type Address, type BlockTag, type Chain, type Client, type Hex, type RpcSchema, type Transport } from 'viem';
+import type { AccountDataDisclosureResult, EthCallDisclosureResult } from './disclosure-result';
+export type DisclosureBlockNumber = number | bigint | Hex | BlockTag;
+export type SelectiveDisclosureActions = {
+    tokenSupplyDisclosure: (tokenAddress: Address, blockNumber: DisclosureBlockNumber) => Promise<EthCallDisclosureResult>;
+    tokenBalanceDisclosure: (tokenAddress: Address, holderAddress: Address, blockNumber: DisclosureBlockNumber) => Promise<EthCallDisclosureResult>;
+    accountDataDisclosure: (address: Address, blockNumber: DisclosureBlockNumber) => Promise<AccountDataDisclosureResult>;
+};
+export type TokenSupplyDisclosureRpc = {
+    Method: 'prividium_tokenSupplyDisclosure';
+    Parameters: [tokenAddress: Address, blockNumber: Hex | BlockTag];
+    ReturnType: EthCallDisclosureResult;
+};
+export type TokenBalanceDisclosureRpc = {
+    Method: 'prividium_tokenBalanceDisclosure';
+    Parameters: [tokenAddress: Address, holderAddress: Address, blockNumber: Hex | BlockTag];
+    ReturnType: EthCallDisclosureResult;
+};
+export type AccountDataDisclosureRpc = {
+    Method: 'prividium_accountDataDisclosure';
+    Parameters: [address: Address, blockNumber: Hex | BlockTag];
+    ReturnType: AccountDataDisclosureResult;
+};
+/**
+ * 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,30 @@
+import { numberToHex } from 'viem';
+function encodeBlockNumber(block) {
+    return typeof block === 'string' ? block : numberToHex(block);
+}
+/**
+ * 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, encodeBlockNumber(blockNumber)]
+            });
+        },
+        async tokenBalanceDisclosure(tokenAddress, holderAddress, blockNumber) {
+            return client.request({
+                method: 'prividium_tokenBalanceDisclosure',
+                params: [tokenAddress, holderAddress, encodeBlockNumber(blockNumber)]
+            });
+        },
+        async accountDataDisclosure(address, blockNumber) {
+            return client.request({
+                method: 'prividium_accountDataDisclosure',
+                params: [address, encodeBlockNumber(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,55 @@
+import type { Address, 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[];
+};
+export type AccountProperties = {
+    versioningData: Hex;
+    nonce: Hex;
+    balance: Hex;
+    bytecodeHash: Hex;
+    unpaddedCodeLen: number;
+    artifactsLen: number;
+    observableBytecodeHash: Hex;
+    observableBytecodeLen: number;
+};
+export type AccountDataDisclosureResult = {
+    accountProperties: AccountProperties;
+    address: Address;
+    bytecode: Hex;
+    batchNumber: number;
+    l1VerificationData: L1VerificationData;
+    stateCommitmentPreimage: StateCommitmentPreimage;
+    storageProof: StorageSlotProof;
+};

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

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

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

@@ -0,0 +1,7 @@
+export * from './account-properties';
+export * from './actions';
+export * from './batch-info';
+export * from './disclosure-result';
+export * from './state-commitment';
+export * from './verifiy-proofs';
+export * from './verify-disclosure';

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

@@ -0,0 +1,7 @@
+export * from './account-properties';
+export * from './actions';
+export * from './batch-info';
+export * from './disclosure-result';
+export * from './state-commitment';
+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/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 blake 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 blake.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,40 @@
+import { type Address, type Hex, type PublicClient } from 'viem';
+import type { EthCallDisclosureResult } from './disclosure-result';
+export declare const DIAMOND_ABI: {
+    readonly name: "storedBatchHash";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "_batchNumber";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "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 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,90 @@
+import { keccak256, pad, parseAbiItem } from 'viem';
+import { encodeBatchInfo } from './batch-info';
+import { computeStateCommitment } from './state-commitment';
+import { calculateStateMerkleRoot } from './verifiy-proofs';
+export const DIAMOND_ABI = [
+    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: DIAMOND_ABI,
+        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/account-properties.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/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.17.0",
   "type": "module",
   "bin": {
     "prividium": "bin/cli.js"
@@ -34,11 +34,12 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "@fastify/http-proxy": "^11.3.0",
+    "@fastify/http-proxy": "^11.4.4",
     "@fastify/static": "^9.0.0",
     "appdirsjs": "^1.2.7",
+    "blakejs": "^1.2.1",
     "date-fns": "^4.1.0",
-    "fastify": "^5.7.2",
+    "fastify": "^5.8.5",
     "fastify-type-provider-zod": "^6.1.0",
     "kleur": "^4.1.5",
     "open": "^10.1.0",