prividium 0.20.0 → 0.21.0

package/dist/cli/commands/verify/erc20-supply-cmd.js

@@ -0,0 +1,102 @@
+import { selectiveDisclosureActions, verifyEthCallDisclosure } from '@repo/prividium-sdk';
+import { createPublicClient, getAddress, hexToBigInt, http } from 'viem';
+import { ConfigFile } from '../../server/config-file.js';
+import { loadBytecodes, parseBlockNumber } from './utils.js';
+import { VerifyWorkflow } from './verify-workflow.js';
+export async function erc20SupplyCmd(opts) {
+    const wf = new VerifyWorkflow();
+    const configFile = new ConfigFile(opts.configPath);
+    wf.start();
+    try {
+        const bytecodes = loadBytecodes(opts.bytecodesFile, opts.bytecodes);
+        const { apiUrl, l1RpcUrl, localZksyncOsRpcUrl, diamondAddress } = await configFile.readAndUpdatedRequiredFields({
+            apiUrl: opts.apiUrl,
+            l1RpcUrl: opts.l1Rpc,
+            localZksyncOsRpcUrl: opts.zkSyncOsRpc,
+            diamondAddress: opts.diamondAddress
+        });
+        const prividiumRpcUrl = new URL('/rpc', apiUrl).toString();
+        const l1Client = createPublicClient({ transport: http(l1RpcUrl) });
+        const l2Client = createPublicClient({ transport: http(localZksyncOsRpcUrl) });
+        const prividiumRpc = createPublicClient({ transport: http(prividiumRpcUrl) }).extend(selectiveDisclosureActions);
+        const disclosure = await wf
+            .step('Gathering proofs', 'Proofs fetched ✅', () => prividiumRpc.tokenSupplyDisclosure(getAddress(opts.tokenAddr), parseBlockNumber(opts.blockNumber)))
+            .catch((e) => {
+            const detail = e instanceof Error ? e.message : 'unexpected error';
+            wf.error(`Error fetching proofs: ${detail}`);
+            process.exit(1);
+        });
+        if (opts.verbose) {
+            wf.message(JSON.stringify(disclosure, null, 2));
+        }
+        const res = await wf
+            .step('Verifying proofs', 'Proofs verified ✅', () => verifyEthCallDisclosure({
+            disclosure,
+            l1Client,
+            l2Client,
+            diamondAddress: getAddress(diamondAddress),
+            contractBytecodes: bytecodes,
+            batchNumber: disclosure.batchNumber
+        }))
+            .catch((e) => {
+            const detail = e instanceof Error ? e.message : 'unexpected error';
+            wf.error(`Verification failed: ${detail}`);
+            process.exit(1);
+        });
+        if (res.success) {
+            wf.success(`Supply: ${hexToBigInt(disclosure.result)}`);
+        }
+        else {
+            wf.error(`Verification failed: ${res.errorMsg}`);
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        if (typeof e === 'object' && e && 'message' in e && typeof e.message === 'string') {
+            wf.error(e.message);
+        }
+        else {
+            wf.error('Unexpected error');
+        }
+        process.exit(1);
+    }
+}
+export const addErc20SupplyCmd = (cli) => cli.command('erc20-total-supply <tokenAddr>', 'Verify an ERC-20 total supply using proofs from L1', (yargs) => yargs
+    .positional('tokenAddr', {
+    description: 'Address of the token',
+    type: 'string',
+    demandOption: true
+})
+    .option('bytecodesFile', {
+    alias: 'bytecodes-file',
+    description: 'JSON file with contracts bytecodes. The file should be a simple object using the addresses as keys with the respective bytecodes as values',
+    type: 'string',
+    demandOption: false
+})
+    .option('bytecodes', {
+    alias: ['address-bytecode', 'addressBytecode', 'contractBytecode', 'contract-bytecode'],
+    description: "Contract bytecode in '0x<address>:0x<bytecode>' format. Repeat the flag for multiple contracts. Alternatively use --bytecodes-file to supply a JSON map.",
+    array: true,
+    demandOption: true,
+    default: [],
+    type: 'string'
+})
+    .option('verbose', {
+    alias: ['v'],
+    description: 'Verbose',
+    type: 'boolean',
+    default: false
+}), async (yargs) => {
+    await erc20SupplyCmd({
+        tokenAddr: yargs.tokenAddr,
+        blockNumber: yargs.blockNumber,
+        diamondAddress: yargs.diamondAddress,
+        l1Rpc: yargs.l1Rpc,
+        zkSyncOsRpc: yargs.zkSyncOsRpc,
+        apiUrl: yargs.apiUrl,
+        bytecodesFile: yargs.bytecodesFile,
+        bytecodes: yargs.bytecodes,
+        configPath: yargs.configPath,
+        verbose: yargs.verbose
+    });
+});

package/dist/cli/commands/verify/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Hex } from 'viem';
+export declare function parseBlockNumber(str: string): bigint;
+export declare function intoAddressCodePair(strings: string[]): [Hex, Hex];
+export declare function parseBytecodes(raw: string[]): Record<Hex, Hex>;
+export declare function loadBytecodes(filePath: string | undefined, raw: string[]): Record<Hex, Hex>;

package/dist/cli/commands/verify/utils.js

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+import { hexSchema } from '../utils/schemas.js';
+export function parseBlockNumber(str) {
+    try {
+        return BigInt(str);
+    }
+    catch {
+        throw new Error('Invalid block number provided');
+    }
+}
+const hexRegex = /0x[a-fA-F0-9]+/;
+export function intoAddressCodePair(strings) {
+    const [addr, code] = strings.filter((part) => hexRegex.test(part));
+    if (addr === undefined || code === undefined) {
+        throw new Error('Wrong bytecode format. Only 1 colon is allowed');
+    }
+    if (addr.length !== 42) {
+        throw new Error(`Invalid value. Expected address received: ${addr}`);
+    }
+    return [addr, code];
+}
+export function parseBytecodes(raw) {
+    const res = {};
+    for (const elem of raw) {
+        const parts = elem.split(':').map((part) => part.trim());
+        const [addr, code] = intoAddressCodePair(parts);
+        res[addr] = code;
+    }
+    return res;
+}
+export function loadBytecodes(filePath, raw) {
+    if (filePath !== undefined) {
+        const data = JSON.parse(readFileSync(filePath).toString());
+        return z.record(hexSchema, hexSchema).parse(data);
+    }
+    return parseBytecodes(raw);
+}

package/dist/cli/commands/verify/verify-workflow.d.ts

@@ -0,0 +1,8 @@
+export declare class VerifyWorkflow {
+    start(): void;
+    step<T>(waitMsg: string, successMessage: string, task: () => Promise<T>): Promise<T>;
+    success(msg: string): void;
+    error(msg: string): void;
+    message(msg: string): void;
+    userConfirmation(msg: string): Promise<boolean>;
+}

package/dist/cli/commands/verify/verify-workflow.js

@@ -0,0 +1,41 @@
+import { setTimeout } from 'node:timers/promises';
+import { confirm, intro, isCancel, log, outro, spinner } from '@clack/prompts';
+import { showPrividiumHeader } from '../utils/show-prividium-header.js';
+export class VerifyWorkflow {
+    start() {
+        showPrividiumHeader();
+        intro('Starting Prividium™ verification tool');
+    }
+    async step(waitMsg, successMessage, task) {
+        const spin = spinner({
+            indicator: 'dots'
+        });
+        spin.start(waitMsg);
+        const [res] = await Promise.all([task(), setTimeout(1500)]).catch((e) => {
+            spin.stop(`❌ ${waitMsg}`);
+            throw e;
+        });
+        spin.stop(successMessage);
+        return res;
+    }
+    success(msg) {
+        outro(msg);
+    }
+    error(msg) {
+        log.error(msg);
+        outro('❌ error');
+    }
+    message(msg) {
+        log.message(msg);
+    }
+    async userConfirmation(msg) {
+        const res = await confirm({
+            message: msg,
+            initialValue: true
+        });
+        if (isCancel(res)) {
+            return false;
+        }
+        return res;
+    }
+}

package/dist/cli/commands/verify.d.ts

@@ -0,0 +1,18 @@
+import type { BaseCli, DefCommand } from '../base-cli.js';
+declare function addVerifyOptions(cli: BaseCli): import("yargs").Argv<{
+    configPath: string | undefined;
+} & {
+    l1Rpc: string | undefined;
+} & {
+    zkSyncOsRpc: string | undefined;
+} & {
+    apiUrl: string | undefined;
+} & {
+    blockNumber: string;
+} & {
+    diamondAddress: string | undefined;
+}>;
+export type VerifyCli = ReturnType<typeof addVerifyOptions>;
+export type VerifyDefCommand = (args: VerifyCli) => VerifyCli;
+export declare const addVerify: DefCommand;
+export {};

package/dist/cli/commands/verify.js

@@ -0,0 +1,43 @@
+import { addVerifyAccountDataCmd } from './verify/account-data-cmd.js';
+import { addErc20BalanceCmd } from './verify/erc20-balance-cmd.js';
+import { addErc20SupplyCmd } from './verify/erc20-supply-cmd.js';
+function addVerifyOptions(cli) {
+    return cli
+        .option('l1Rpc', {
+        alias: ['l1-rpc', 'l1'],
+        description: 'Url for l1 rpc',
+        demandOption: false,
+        type: 'string'
+    })
+        .option('zkSyncOsRpc', {
+        alias: ['zksync-os-rpc', 'zksync-os'],
+        description: 'ZKsync OS RPC used to replay the disclosed EVM call locally with proof-derived state overrides. Does not need historical state — a freshly started node works.',
+        demandOption: false,
+        type: 'string'
+    })
+        .option('apiUrl', {
+        alias: ['api-url', 'rpc-url', 'r', 'prividium-rpc', 'prividium'],
+        description: 'Specifies target Prividium™ API url',
+        demandOption: false,
+        type: 'string'
+    })
+        .option('blockNumber', {
+        alias: ['block-number', 'height'],
+        description: 'block number in hex',
+        demandOption: true,
+        type: 'string'
+    })
+        .option('diamondAddress', {
+        alias: ['diamond-address'],
+        description: 'Address for the diamond in l1',
+        type: 'string'
+    });
+}
+export const addVerify = (cli) => {
+    return cli
+        .command('verify', 'Verify proofs of data from a prividium chain', (cli) => {
+        const withVerifyOpts = addVerifyOptions(cli);
+        return [addErc20SupplyCmd, addErc20BalanceCmd, addVerifyAccountDataCmd].reduce((a, b) => b(a), withVerifyOpts);
+    })
+        .demandCommand();
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+export declare function buildCli(): import("yargs").Argv<{
+    configPath: string | undefined;
+}>;

package/dist/cli/index.js

@@ -0,0 +1,11 @@
+import { createBaseCli } from './base-cli.js';
+import { addConfig } from './commands/config.js';
+import { addDoctor } from './commands/doctor.js';
+import { addProxy } from './commands/proxy.js';
+import { addVerify } from './commands/verify.js';
+const actions = [addProxy, addDoctor, addConfig, addVerify];
+export function buildCli() {
+    const base = createBaseCli();
+    const composed = actions.reduce((argv, applyAction) => applyAction(argv), base);
+    return composed.help().strict().demandCommand();
+}

package/dist/cli/server/config-file.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+declare const schemas: {
+    readonly latest: z.ZodObject<{
+        userPanelUrl: z.ZodOptional<z.ZodString>;
+        apiUrl: z.ZodOptional<z.ZodString>;
+        l1RpcUrl: z.ZodOptional<z.ZodString>;
+        localZksyncOsRpcUrl: z.ZodOptional<z.ZodString>;
+        diamondAddress: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly v0_17: z.ZodObject<{
+        prividiumRpcUrl: z.ZodString;
+        userPanelUrl: z.ZodString;
+    }, z.core.$strip>;
+};
+declare const PROMPTS_FOR_CONFIGS: {
+    readonly userPanelUrl: {
+        readonly msg: "Please insert your Prividium™ User Panel url";
+        readonly retry: "Please provide a valid url";
+        readonly schema: z.ZodURL;
+    };
+    readonly apiUrl: {
+        readonly msg: "Please insert your Prividium™ api url";
+        readonly retry: "Please provide a valid url";
+        readonly schema: z.ZodURL;
+    };
+    readonly diamondAddress: {
+        readonly msg: "Please provide the address of the ZKsync OS main contract in l1";
+        readonly retry: "Please provide a valid address";
+        readonly schema: z.ZodTemplateLiteral<`0x${string}`>;
+    };
+    readonly l1RpcUrl: {
+        readonly msg: "Please provide an rpc url for the l1 chain";
+        readonly retry: "Please provide a valid url";
+        readonly schema: z.ZodURL;
+    };
+    readonly localZksyncOsRpcUrl: {
+        readonly msg: "Please provide an url for a local and trusted zksyncos rpc";
+        readonly retry: "Please provide a valid url";
+        readonly schema: z.ZodURL;
+    };
+};
+type MsgKeys = keyof typeof PROMPTS_FOR_CONFIGS;
+export type CliConfig = z.infer<typeof schemas.latest>;
+type NoUndefinedFields<T> = {
+    [K in keyof T]-?: Exclude<T[K], undefined>;
+};
+type WithUndefinedFields<T> = {
+    [K in keyof T]?: T[K] | null | undefined;
+};
+export declare class ConfigFile {
+    private filePath;
+    constructor(filePath?: string);
+    read(): Partial<CliConfig>;
+    write(config: CliConfig): void;
+    partialWrite(newConfig: Partial<CliConfig>): void;
+    remove(): void;
+    print(): void;
+    printPath(): void;
+    readAndUpdatedRequiredFields<K extends keyof CliConfig>(given: WithUndefinedFields<Pick<CliConfig, K>>): Promise<NoUndefinedFields<Pick<CliConfig, K>>>;
+    prompt(key: MsgKeys): Promise<string>;
+}
+export {};

package/dist/cli/server/config-file.js

@@ -0,0 +1,167 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { confirm, log, text } from '@clack/prompts';
+import appDirs from 'appdirsjs';
+import color from 'kleur';
+import { z } from 'zod';
+import { hexSchema } from '../commands/utils/schemas.js';
+// biome-ignore lint/suspicious/noExplicitAny: CJS/ESM interop
+const appDirsFn = (appDirs.default ?? appDirs);
+const dirs = appDirsFn({ appName: 'prividium-proxy' });
+// Source of truth for the on-disk config-file shapes the SDK accepts.
+// `latest` is what `write()` produces today.
+// Any other entry is keyed by the last SDK version that wrote that shape;
+// it exists only so older config files keep working after a user upgrades.
+// To add a new legacy entry: copy the previous `latest` into a new `vX_Y`
+// key, then change `latest` to the new shape and add a branch in `migrate()`.
+const schemas = {
+    latest: z.object({
+        userPanelUrl: z.string().optional(),
+        apiUrl: z.string().optional(),
+        l1RpcUrl: z.string().optional(),
+        localZksyncOsRpcUrl: z.string().optional(),
+        diamondAddress: z.string().optional()
+    }),
+    v0_17: z.object({
+        prividiumRpcUrl: z.string(),
+        userPanelUrl: z.string()
+    })
+};
+const ENV_VARS_FOR_CONFIG = {
+    apiUrl: 'PRIVIDIUM_API_URL',
+    l1RpcUrl: 'L1_RPC_URL',
+    diamondAddress: 'ZSYNCOS_L1_DIAMOND',
+    userPanelUrl: 'USER_PANEL_URL',
+    localZksyncOsRpcUrl: 'LOCAL_ZKSYNCOS_RPC_URL'
+};
+const PROMPTS_FOR_CONFIGS = {
+    userPanelUrl: {
+        msg: 'Please insert your Prividium™ User Panel url',
+        retry: 'Please provide a valid url',
+        schema: z.url()
+    },
+    apiUrl: {
+        msg: 'Please insert your Prividium™ api url',
+        retry: 'Please provide a valid url',
+        schema: z.url()
+    },
+    diamondAddress: {
+        msg: 'Please provide the address of the ZKsync OS main contract in l1',
+        retry: 'Please provide a valid address',
+        schema: hexSchema
+    },
+    l1RpcUrl: {
+        msg: 'Please provide an rpc url for the l1 chain',
+        retry: 'Please provide a valid url',
+        schema: z.url()
+    },
+    localZksyncOsRpcUrl: {
+        msg: 'Please provide an url for a local and trusted zksyncos rpc',
+        retry: 'Please provide a valid url',
+        schema: z.url()
+    }
+};
+function migrate(json) {
+    const latest = schemas.latest.safeParse(json);
+    if (latest.success)
+        return latest.data;
+    const v0_17 = schemas.v0_17.safeParse(json);
+    if (v0_17.success)
+        return { apiUrl: v0_17.data.prividiumRpcUrl };
+    return null;
+}
+export class ConfigFile {
+    filePath;
+    constructor(filePath) {
+        if (filePath) {
+            this.filePath = filePath;
+        }
+        else {
+            this.filePath = path.join(dirs.config, 'config.json');
+        }
+    }
+    read() {
+        if (!existsSync(this.filePath)) {
+            return {};
+        }
+        else {
+            const data = readFileSync(this.filePath).toString();
+            try {
+                const json = JSON.parse(data);
+                return migrate(json) ?? {};
+            }
+            catch {
+                rmSync(this.filePath);
+                log.warn('Corrupted configuration file');
+                return {};
+            }
+        }
+    }
+    write(config) {
+        const dir = path.parse(this.filePath).dir;
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(this.filePath, JSON.stringify({ latest: config }));
+    }
+    partialWrite(newConfig) {
+        const old = this.read();
+        const dir = path.parse(this.filePath).dir;
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(this.filePath, JSON.stringify({ latest: { ...old, ...newConfig } }));
+    }
+    remove() {
+        if (existsSync(this.filePath)) {
+            rmSync(this.filePath);
+        }
+    }
+    print() {
+        const { apiUrl } = this.read();
+        console.log(`${color.bold('Prividium™ API url')}: ${apiUrl}`);
+    }
+    printPath() {
+        console.log(this.filePath);
+    }
+    async readAndUpdatedRequiredFields(given) {
+        const res = {};
+        const existing = this.read();
+        for (const key in given) {
+            if (given[key] !== null && given[key] !== undefined) {
+                res[key] = given[key];
+            }
+            else if (key in existing) {
+                res[key] = existing[key];
+            }
+            else if (ENV_VARS_FOR_CONFIG[key] && ENV_VARS_FOR_CONFIG[key] in process.env) {
+                res[key] = process.env[ENV_VARS_FOR_CONFIG[key]];
+            }
+            else {
+                res[key] = await this.prompt(key);
+            }
+        }
+        return res;
+    }
+    async prompt(key) {
+        const response = await text({
+            message: PROMPTS_FOR_CONFIGS[key].msg,
+            validate(value) {
+                const parsed = PROMPTS_FOR_CONFIGS[key].schema.safeParse(value);
+                if (!parsed.success) {
+                    return PROMPTS_FOR_CONFIGS[key].retry;
+                }
+            }
+        });
+        if (typeof response === 'symbol') {
+            throw new Error('Canceled by the user');
+        }
+        const save = await confirm({
+            message: 'Do you want to save this value for future usages?',
+            initialValue: true
+        });
+        if (typeof save === 'symbol') {
+            throw new Error('Canceled by the user');
+        }
+        if (save) {
+            this.partialWrite({ [key]: response });
+        }
+        return response;
+    }
+}

package/dist/cli/server/connection-workflow.d.ts

@@ -0,0 +1,12 @@
+export declare class CreationWorkflow {
+    private submitCallback;
+    private host;
+    private port;
+    constructor(host: string, port: number);
+    start(): void;
+    waitForAuthentication(url: string): Promise<void>;
+    private openBrowser;
+    onSubmit(): Promise<void>;
+    onMessage(msg: string): void;
+    onError(err: Error): void;
+}

package/dist/cli/server/server.d.ts

@@ -0,0 +1,28 @@
+import { type ZodTypeProvider } from 'fastify-type-provider-zod';
+import { z } from 'zod';
+declare function fastifyApp(): import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, ZodTypeProvider>;
+type WebServer = ReturnType<typeof fastifyApp>;
+type Config = {
+    apiUrl: string;
+    userPanelUrl?: string;
+    host: string;
+    port: number;
+    onSubmit: () => Promise<void>;
+    onCall: (methodName: string) => void;
+    onReAuthNeeded: () => void;
+    onError: (err: Error) => void;
+    initialToken?: {
+        accessToken: string;
+        expiresAt: Date;
+    };
+    onReAuth?: () => Promise<{
+        accessToken: string;
+        expiresAt: Date;
+    }>;
+};
+export declare const sessionSchema: z.ZodObject<{
+    type: z.ZodString;
+    expiresAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export declare function buildServer(config: Config): WebServer;
+export {};

package/dist/sdk/create-prividium-client.d.ts

@@ -1,5 +1,5 @@
 import { type Account, type Chain, type ClientConfig, type PublicClient, type PublicClientConfig, type RpcSchema, type Transport } from 'viem';
-import { type SelectiveDisclosureActions } from './selective-disclosure/actions.js';
+import { type SelectiveDisclosureActions } from './selective-disclosure/index.js';
 type PrividiumClientConfig<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, accountOrAddress extends Account | undefined = undefined, rpcSchema extends RpcSchema | undefined = undefined> = PublicClientConfig<transport, chain, accountOrAddress, rpcSchema> & Pick<ClientConfig<transport, chain, accountOrAddress, rpcSchema>, 'account'>;
 /**
  * Creates a Prividium specific Public Client. This client extends the standard Viem Public Client

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

@@ -1,5 +1,5 @@
 import { createClient, publicActions } from 'viem';
-import { selectiveDisclosureActions } from './selective-disclosure/actions.js';
+import { selectiveDisclosureActions } from './selective-disclosure/index.js';
 function prividiumActions(client) {
     return {
         call: (args) => {

package/dist/sdk/selective-disclosure/account-properties.d.ts

@@ -9,4 +9,10 @@ export declare function computeInternalBytecodeHash(codeHex: Hex): {
     bytecodeHash: Hex;
     artifactsLen: number;
 };
-export declare function verifyAccountPropertiesProof(disclosure: AccountDataDisclosureResult, l1Client: PublicClient, diamondAddress: Address, expectedBytecode?: Hex): Promise<boolean>;
+export type VerifyAccountPropertiesResult = {
+    success: true;
+} | {
+    success: false;
+    errorMsg: string;
+};
+export declare function verifyAccountPropertiesProof(disclosure: AccountDataDisclosureResult, l1Client: PublicClient, diamondAddress: Address, expectedBytecode?: Hex, expectedAddress?: Hex): Promise<VerifyAccountPropertiesResult>;

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

@@ -1,7 +1,7 @@
-import { bytesToHex, hexToBigInt, hexToBytes, keccak256, pad } from 'viem';
+import { bytesToHex, getAddress, hexToBigInt, hexToBytes, keccak256, pad } from 'viem';
 import { encodeBatchInfo } from './batch-info.js';
 import { computeStateCommitment } from './state-commitment.js';
-import { blake2s256 } from './utils.js';
+import { areHexEqual, blake2s256 } from './utils.js';
 import { calculateStateMerkleRoot } from './verifiy-proofs.js';
 import { DIAMOND_ABI } from './verify-disclosure.js';
 const PUSH1 = 0x60;
@@ -43,25 +43,31 @@ export function computeInternalBytecodeHash(codeHex) {
     };
 }
 const ACCOUNT_PROPERTIES_ADDRESS = '0x0000000000000000000000000000000000008003';
-export async function verifyAccountPropertiesProof(disclosure, l1Client, diamondAddress, expectedBytecode) {
+export async function verifyAccountPropertiesProof(disclosure, l1Client, diamondAddress, expectedBytecode, expectedAddress) {
     const isEoa = BigInt(disclosure.accountProperties.bytecodeHash) === 0n;
     if (isEoa && expectedBytecode !== undefined && BigInt(expectedBytecode) !== 0n) {
-        return false;
+        return { success: false, errorMsg: 'EOA should not have bytecode' };
     }
     if (!isEoa) {
         if (expectedBytecode === undefined) {
-            return false;
+            return { success: false, errorMsg: 'Missing expected bytecode for contract' };
         }
         const { bytecodeHash: computedHash } = computeInternalBytecodeHash(expectedBytecode);
-        if (computedHash.toLowerCase() !== disclosure.accountProperties.bytecodeHash.toLowerCase()) {
-            return false;
+        if (!areHexEqual(computedHash, disclosure.accountProperties.bytecodeHash)) {
+            return { success: false, errorMsg: "Bytecode hash doesn't match" };
         }
     }
+    if (expectedAddress !== undefined && !areHexEqual(expectedAddress, disclosure.address)) {
+        return {
+            success: false,
+            errorMsg: `Disclosure address does not match with expected address. Expected ${getAddress(expectedAddress)}, included in disclosure payload: ${getAddress(disclosure.address)} `
+        };
+    }
     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;
+    if (propertiesHash === null || !areHexEqual(bytesToHex(reconstructedHash), propertiesHash)) {
+        return { success: false, errorMsg: "Account properties hash doesn't match the storage proof value" };
     }
     // 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));
@@ -74,7 +80,13 @@ export async function verifyAccountPropertiesProof(disclosure, l1Client, diamond
         functionName: 'storedBatchHash',
         args: [BigInt(disclosure.batchNumber)]
     });
-    return batchInfoHash.toLowerCase() === storedBatchHash.toLowerCase();
+    const success = areHexEqual(batchInfoHash, storedBatchHash);
+    if (success) {
+        return { success: true };
+    }
+    else {
+        return { success: false, errorMsg: 'Storage proof verification failed.' };
+    }
 }
 /**
  * Build the JUMPDEST bitmap matching the ZKsync OS evm_interpreter `analyze()`.

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

@@ -1,2 +1,4 @@
+import type { Hex } from 'viem';
 export declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
 export declare function blake2s256(data: Uint8Array): Uint8Array;
+export declare function areHexEqual(hex1: Hex, hex2: Hex): boolean;

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

@@ -12,3 +12,6 @@ export function concatBytes(...arrays) {
 export function blake2s256(data) {
     return blake.blake2s(data, undefined, 32);
 }
+export function areHexEqual(hex1, hex2) {
+    return hex1.toLowerCase() === hex2.toLowerCase();
+}