prividium 0.16.0 → 0.17.1

package/dist/sdk/error-utils.d.ts

@@ -2,6 +2,7 @@
  * Checks if a Response contains a Prividium unauthorized/forbidden error.
  */
 export declare function hasPrividiumUnauthorizedError(response: Response): Promise<boolean>;
+export declare function isPrividiumUnauthorizedRpcError(error: unknown): boolean;
 /**
  * Extracts a human-readable error string from a failed HTTP response.
  * Attempts to parse the server's `{ error: { code, message } }` JSON structure,

package/dist/sdk/error-utils.js

@@ -17,13 +17,27 @@ const apiErrorSchema = z.object({
  * Checks if a Response contains a Prividium unauthorized/forbidden error.
  */
 export async function hasPrividiumUnauthorizedError(response) {
-    const clonedResponse = response.clone();
-    const parsed = jsonRpcErrorSchema.safeParse(await clonedResponse.json());
-    // { success: false, error: {...} } | { success: true, data: {...} }
-    if (parsed.success) {
-        return parsed.data.error.code === UNAUTHORIZED_ERROR_CODE;
+    try {
+        const clonedResponse = response.clone();
+        const parsed = jsonRpcErrorSchema.safeParse(await clonedResponse.json());
+        if (parsed.success) {
+            return parsed.data.error.code === UNAUTHORIZED_ERROR_CODE;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+export function isPrividiumUnauthorizedRpcError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const value = error;
+    if (value.code === UNAUTHORIZED_ERROR_CODE) {
+        return true;
     }
-    return false;
+    return isPrividiumUnauthorizedRpcError(value.cause);
 }
 /**
  * Extracts a human-readable error string from a failed HTTP response.

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

@@ -1,8 +1,25 @@
-import { type Account, type Address, type Chain, type Client, type RpcSchema, type Transport } from 'viem';
-import type { EthCallDisclosureResult } from './disclosure-result';
+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: number | bigint) => Promise<EthCallDisclosureResult>;
-    tokenBalanceDisclosure: (tokenAddress: Address, holderAddress: Address, blockNumber: number | bigint) => Promise<EthCallDisclosureResult>;
+    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

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

@@ -1,4 +1,7 @@
 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)`.
@@ -8,13 +11,19 @@ export function selectiveDisclosureActions(client) {
         async tokenSupplyDisclosure(tokenAddress, blockNumber) {
             return client.request({
                 method: 'prividium_tokenSupplyDisclosure',
-                params: [tokenAddress, numberToHex(blockNumber)]
+                params: [tokenAddress, encodeBlockNumber(blockNumber)]
             });
         },
         async tokenBalanceDisclosure(tokenAddress, holderAddress, blockNumber) {
             return client.request({
                 method: 'prividium_tokenBalanceDisclosure',
-                params: [tokenAddress, holderAddress, numberToHex(blockNumber)]
+                params: [tokenAddress, holderAddress, encodeBlockNumber(blockNumber)]
+            });
+        },
+        async accountDataDisclosure(address, blockNumber) {
+            return client.request({
+                method: 'prividium_accountDataDisclosure',
+                params: [address, encodeBlockNumber(blockNumber)]
             });
         }
     };

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

@@ -1,4 +1,4 @@
-import type { Hex } from 'viem';
+import type { Address, Hex } from 'viem';
 import type { StorageSlotProof } from './verifiy-proofs';
 export type StateCommitmentPreimage = {
     nextFreeSlot: Hex;
@@ -34,3 +34,22 @@ export type EthCallDisclosureResult = {
     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/index.d.ts

@@ -1,8 +1,7 @@
+export * from './account-properties';
 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

@@ -1,8 +1,7 @@
+export * from './account-properties';
 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/utils.js

@@ -1,4 +1,4 @@
-import { blake2s } from 'blakejs';
+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);
@@ -10,5 +10,5 @@ export function concatBytes(...arrays) {
     return result;
 }
 export function blake2s256(data) {
-    return blake2s(data, undefined, 32);
+    return blake.blake2s(data, undefined, 32);
 }

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

@@ -1,5 +1,17 @@
 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.
  *

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

@@ -2,7 +2,9 @@ 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)')];
+export const DIAMOND_ABI = [
+    parseAbiItem('function storedBatchHash(uint256 _batchNumber) external view returns (bytes32)')
+];
 /**
  * Verifies an ethCall disclosure response end-to-end.
  *
@@ -51,7 +53,7 @@ export async function verifyEthCallDisclosure(disclosure, l1Client, l2Client, di
     // Step 4: Verify against L1 diamond proxy.
     const storedBatchHash = await l1Client.readContract({
         address: diamondAddress,
-        abi: diamondAbi,
+        abi: DIAMOND_ABI,
         functionName: 'storedBatchHash',
         args: [BigInt(batchNumber)]
     });

package/dist/sdk/siwe-chain.js

@@ -1,6 +1,6 @@
 import { http } from 'viem';
 import { buildChainObject, createApiMethods, rpcUrl } from './chain-core.js';
-import { extractResponseError, hasPrividiumUnauthorizedError } from './error-utils.js';
+import { extractResponseError, isPrividiumUnauthorizedRpcError } from './error-utils.js';
 import { PrividiumSessionError } from './errors.js';
 import { MemoryStorage } from './memory-storage.js';
 import { SiweAuth } from './siwe-auth.js';
@@ -112,16 +112,12 @@ export function createPrividiumSiweChain(config) {
         return parsed.data;
     }
     // Create transport with auth integration using viem callbacks
-    const transport = http(rpcUrl(config.prividiumApiBaseUrl), {
+    const baseTransport = http(rpcUrl(config.prividiumApiBaseUrl), {
         batch: false,
         fetchOptions: {
             headers: getAuthHeaders() || {}
         },
         onFetchRequest(_request, init) {
-            // Don't throw on expired token — let the request go through
-            // so onFetchResponse can handle the 401 and trigger reauthentication.
-            // Throwing here creates a deadlock: no request is sent, so onFetchResponse
-            // (which is the only reauth trigger for RPC calls) never fires.
             const authHeaders = getAuthHeaders();
             if (authHeaders) {
                 init.headers = {
@@ -129,24 +125,32 @@ export function createPrividiumSiweChain(config) {
                     ...authHeaders
                 };
             }
-        },
-        onFetchResponse: async (response) => {
-            if (await hasPrividiumUnauthorizedError(response)) {
-                tokenManager.clearToken();
-                if (autoReauth) {
-                    try {
-                        await reauthenticate();
+        }
+    });
+    const transport = (parameters) => {
+        const base = baseTransport(parameters);
+        return {
+            ...base,
+            async request(request) {
+                await ensureAuthorized();
+                try {
+                    return await base.request(request);
+                }
+                catch (error) {
+                    if (!isPrividiumUnauthorizedRpcError(error)) {
+                        throw error;
                     }
-                    catch {
+                    if (!autoReauth) {
                         config.onAuthExpiry?.();
+                        throw error;
                     }
-                }
-                else {
-                    config.onAuthExpiry?.();
+                    tokenManager.clearToken();
+                    await reauthenticate();
+                    return base.request(request);
                 }
             }
-        }
-    });
+        };
+    };
     const apiMethods = createApiMethods({ prividiumApiCall, prividiumApiBaseUrl: config.prividiumApiBaseUrl });
     return {
         chain: buildChainObject(config),

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","../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"}
+{"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.16.0",
+  "version": "0.17.1",
   "type": "module",
   "bin": {
     "prividium": "bin/cli.js"
@@ -34,12 +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",

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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,7 +0,0 @@
-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

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