prividium 0.20.0 → 0.21.0

package/bin/cli.js

@@ -1,2 +1,9 @@
 #!/usr/bin/env node
-import '../dist/cli/cli/index.js';
+import { buildCli } from '../dist/cli/index.js';
+
+buildCli()
+    .parseAsync(process.argv.slice(2))
+    .catch((e) => {
+        console.error(e);
+        process.exit(1);
+    });

package/dist/cli/base-cli.d.ts

@@ -0,0 +1,5 @@
+export declare function createBaseCli(): import("yargs").Argv<{
+    configPath: string | undefined;
+}>;
+export type BaseCli = ReturnType<typeof createBaseCli>;
+export type DefCommand = (args: BaseCli) => BaseCli;

package/dist/cli/base-cli.js

@@ -0,0 +1,11 @@
+import yargs from 'yargs';
+export function createBaseCli() {
+    return yargs()
+        .scriptName('prividium-cli')
+        .option('configPath', {
+        alias: ['c', 'config-path', 'config'],
+        description: 'Path for config file. By default config file is stored under user personal folder',
+        type: 'string',
+        demandOption: false
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { DefCommand } from '../base-cli.js';
+export declare const addConfig: DefCommand;

package/dist/cli/commands/doctor/clients/browser-auth.d.ts

@@ -0,0 +1 @@
+export declare function authenticateInBrowser(userPanelBaseUrl: string, callbackPort: number): Promise<string>;

package/dist/cli/commands/doctor/clients/http.d.ts

@@ -0,0 +1,3 @@
+import type { z } from 'zod';
+export declare function requireHttpOk(url: URL): Promise<void>;
+export declare function fetchAuthenticatedJson<Schema extends z.ZodTypeAny>(schema: Schema, url: string, token: string): Promise<z.infer<Schema>>;

package/dist/cli/commands/doctor/clients/rpc.d.ts

@@ -0,0 +1,19 @@
+export type RpcResponse = {
+    result?: string;
+    error?: {
+        code: number;
+        message: string;
+    };
+};
+type RpcCallOptions = {
+    method: string;
+    params?: unknown[];
+    path?: string;
+    token?: string;
+};
+export declare function callRpc(apiBaseUrl: string, { method, params, path, token }: RpcCallOptions): Promise<RpcResponse>;
+export declare function requireRpcResult(apiBaseUrl: string, options: RpcCallOptions): Promise<string>;
+export declare function requireForbiddenRpc(apiBaseUrl: string, options: RpcCallOptions): Promise<void>;
+export declare function formatRpcError(method: string, rpcResponse: RpcResponse): string;
+export declare function isForbiddenRpc(rpcResponse: RpcResponse): boolean;
+export {};

package/dist/cli/commands/doctor/clients/wallet-api.d.ts

@@ -0,0 +1,7 @@
+export declare function fetchWalletRpcToken(apiBaseUrl: string, token: string): Promise<{
+    token: string;
+}>;
+export declare function authorizeTransactionProbe(apiBaseUrl: string, token: string, walletAddress: string, nonce: bigint): Promise<{
+    activeUntil: string;
+    message: string;
+}>;

package/dist/cli/commands/doctor/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_DOCTOR_CALLBACK_PORT = 24101;

package/dist/cli/commands/doctor/probes/authentication/authentication.d.ts

@@ -0,0 +1,4 @@
+import type { DoctorContext } from '../../types.js';
+export declare function runBrowserAuthProbe(context: DoctorContext): Promise<void>;
+export declare function runSessionValidationProbe(context: DoctorContext): Promise<void>;
+export declare function runProfileFetchProbe(context: DoctorContext): Promise<void>;

package/dist/cli/commands/doctor/probes/authentication/wallet-preconditions.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorContext, ProbeOutput } from '../../types.js';
+export declare function runWalletPreconditionsProbe(context: DoctorContext): Promise<ProbeOutput>;

package/dist/cli/commands/doctor/probes/authentication.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorStageDefinition } from '../types.js';
+export declare const authenticationStage: DoctorStageDefinition;

package/dist/cli/commands/doctor/probes/bridging/bridging.d.ts

@@ -0,0 +1,5 @@
+import type { DoctorContext, ProbeOutput } from '../../types.js';
+export declare function runBridgingL1ChainIdProbe(ctx: DoctorContext, walletAddress: string): Promise<ProbeOutput>;
+export declare function runBridgingBaseTokenProbe(ctx: DoctorContext, walletAddress: string): Promise<ProbeOutput>;
+export declare function runBridgingWethTokenProbe(ctx: DoctorContext, walletAddress: string): Promise<ProbeOutput>;
+export declare function runBridgingOriginChainIdProbe(ctx: DoctorContext, walletAddress: string): Promise<ProbeOutput>;

package/dist/cli/commands/doctor/probes/bridging.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorStageDefinition } from '../types.js';
+export declare function createBridgingStage(walletAddress: string): DoctorStageDefinition;

package/dist/cli/commands/doctor/probes/global/input-validation.d.ts

@@ -0,0 +1,3 @@
+import type { DoctorContext, ProbeOutput } from '../../types.js';
+export declare function runInputValidationProbe(context: DoctorContext): Promise<void>;
+export declare function runHostMismatchProbe(context: DoctorContext): Promise<ProbeOutput | undefined>;

package/dist/cli/commands/doctor/probes/global/reachability.d.ts

@@ -0,0 +1,5 @@
+import type { DoctorContext, ProbeOutput } from '../../types.js';
+export declare function runCallbackPortProbe(): Promise<void>;
+export declare function runUserPanelReachabilityProbe(context: DoctorContext): Promise<void>;
+export declare function runApiHealthProbe(context: DoctorContext): Promise<ProbeOutput>;
+export declare function runPublicRpcProbe(context: DoctorContext): Promise<ProbeOutput>;

package/dist/cli/commands/doctor/probes/global.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorStageDefinition } from '../types.js';
+export declare const globalStage: DoctorStageDefinition;

package/dist/cli/commands/doctor/probes/wallet/authenticated-rpc.d.ts

@@ -0,0 +1,3 @@
+import type { DoctorContext, ProbeOutput } from '../../types.js';
+export declare function runAuthBalanceProbe(context: DoctorContext, walletAddress: string): Promise<ProbeOutput>;
+export declare function runAuthNonceProbe(context: DoctorContext, walletAddress: string): Promise<ProbeOutput>;

package/dist/cli/commands/doctor/probes/wallet/authorization-and-wallet-rpc.d.ts

@@ -0,0 +1,5 @@
+import type { DoctorContext, ProbeOutput } from '../../types.js';
+export declare function runTransactionAuthorizationProbe(context: DoctorContext, walletAddress: string): Promise<void>;
+export declare function runWalletBalanceProbe(context: DoctorContext, walletAddress: string): Promise<ProbeOutput>;
+export declare function runWalletEthCallRestrictionProbe(context: DoctorContext, walletAddress: string): Promise<void>;
+export declare function runWalletTxCountRestrictionProbe(context: DoctorContext, walletAddress: string): Promise<void>;

package/dist/cli/commands/doctor/probes/wallet-api.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorStageDefinition } from '../types.js';
+export declare const walletApiStage: DoctorStageDefinition;

package/dist/cli/commands/doctor/probes/wallet.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorStageDefinition } from '../types.js';
+export declare function createWalletStage(walletAddress: string, index: number, total: number): DoctorStageDefinition;

package/dist/cli/commands/doctor/profile.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const profileSchema: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    roles: z.ZodArray<z.ZodObject<{
+        roleName: z.ZodString;
+    }, z.core.$strip>>;
+    wallets: z.ZodArray<z.ZodObject<{
+        walletAddress: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DoctorProfileSchema = typeof profileSchema;

package/dist/cli/commands/doctor/report/build.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorContext, DoctorReport, DoctorStageDefinition } from '../types.js';
+export declare function buildDoctorReport(context: DoctorContext, stages: DoctorStageDefinition[]): DoctorReport;

package/dist/cli/commands/doctor/report/render.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorReport } from '../types.js';
+export declare function printReport(report: DoctorReport): void;

package/dist/cli/commands/doctor/stages.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorContext, DoctorStageDefinition } from './types.js';
+export declare function executeDoctorStages(context: DoctorContext, stages: DoctorStageDefinition[]): Promise<void>;

package/dist/cli/commands/doctor/types.d.ts

@@ -0,0 +1,90 @@
+import type { z } from 'zod';
+import type { sessionSchema } from '../../server/server.js';
+import type { DoctorProfileSchema } from './profile.js';
+export type Options = {
+    rpcUrl?: string;
+    userPanelUrl?: string;
+    configPath?: string;
+};
+export type NormalizedTargets = {
+    apiBaseUrl: string;
+    userPanelBaseUrl: string;
+};
+export type ReportStatus = 'pass' | 'warn' | 'fail' | 'skip';
+export type ReportValue = {
+    label: string;
+    value: string;
+    inline?: boolean;
+};
+export type ProbeOutput = {
+    status?: Exclude<ReportStatus, 'fail' | 'skip'>;
+    values?: ReportValue[];
+    details?: string[];
+};
+export type ReportContext = {
+    authExpiresAt: string;
+    roles: string[];
+    sessionType: string;
+    userDisplayName: string;
+    userId: string;
+    walletCount: number;
+};
+export type ProbeResult = {
+    id: string;
+    label: string;
+    status: ReportStatus;
+    details?: string[];
+    values?: ReportValue[];
+    section: string;
+};
+export type ReportBlock = {
+    type: 'values';
+    id: string;
+    title: string;
+    values: ReportValue[];
+} | {
+    type: 'section';
+    id: string;
+    title: string;
+    probes: ProbeResult[];
+};
+export type DoctorReport = {
+    status: ReportStatus;
+    blocks: ReportBlock[];
+};
+export type AuthenticatedDoctorState = {
+    token: string;
+    profile: z.infer<DoctorProfileSchema>;
+    session: z.infer<typeof sessionSchema>;
+};
+export type DoctorContext = {
+    rawRpcUrl: string;
+    rawUserPanelUrl: string;
+    targets?: NormalizedTargets;
+    authState?: AuthenticatedDoctorState;
+    reportContext?: ReportContext;
+    walletAddresses: string[];
+    walletApiAvailable: boolean;
+    walletApiPath?: string;
+    results: ProbeResult[];
+    pendingToken?: string;
+    pendingSession?: z.infer<typeof sessionSchema>;
+    apiVersion?: string;
+};
+export type DoctorProbeDefinition = {
+    id: string;
+    label: string;
+    progressMessage?: string;
+    runIf?: (context: DoctorContext) => {
+        run: true;
+    } | {
+        run: false;
+        reason: string;
+    };
+    run?: (context: DoctorContext) => Promise<ProbeOutput | undefined> | Promise<void>;
+};
+export type DoctorStageDefinition = {
+    id: string;
+    title: string;
+    getProbes: (context: DoctorContext) => DoctorProbeDefinition[];
+};

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

@@ -0,0 +1,18 @@
+import type { DoctorContext, NormalizedTargets } from './types.js';
+export declare function passed(id: string, reason: string): (ctx: DoctorContext) => {
+    run: true;
+} | {
+    run: false;
+    reason: string;
+};
+export declare function passed(...deps: [string, string][]): (ctx: DoctorContext) => {
+    run: true;
+} | {
+    run: false;
+    reason: string;
+};
+export declare function formatHexQuantity(value: string): string;
+export declare function shortenAddress(address: string): string;
+export declare function getRawReason(status: number, body: string): string;
+export declare function getThrownReason(error: unknown): string;
+export declare function validateAndNormalizeUrls(prividiumRpcUrl: string, userPanelUrl: string): NormalizedTargets;

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

@@ -0,0 +1,2 @@
+import type { DefCommand } from '../base-cli.js';
+export declare const addDoctor: DefCommand;

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

@@ -0,0 +1,2 @@
+import type { DefCommand } from '../base-cli.js';
+export declare const addProxy: DefCommand;

package/dist/cli/{cli/commands → commands}/proxy.js

@@ -1,10 +1,8 @@
 import { intro, log, text } from '@clack/prompts';
+import { MemoryStorage, SiweAuth, TokenManager } from '@repo/prividium-sdk/siwe';
 import color from 'kleur';
 import { privateKeyToAccount } from 'viem/accounts';
 import { z } from 'zod';
-import { MemoryStorage } from '../../src/memory-storage.js';
-import { SiweAuth } from '../../src/siwe-auth.js';
-import { TokenManager } from '../../src/storage.js';
 import { CreationWorkflow } from '../server/connection-workflow.js';
 import { buildServer } from '../server/server.js';
 import { showPrividiumHeader } from './utils/show-prividium-header.js';

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

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const hexSchema: z.ZodTemplateLiteral<`0x${string}`>;
+export declare const addressSchema: z.ZodTemplateLiteral<`0x${string}`>;

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

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export const hexSchema = z.templateLiteral(['0x', z.string().regex(/^[0-9a-fA-F]*$/)]);
+export const addressSchema = z.templateLiteral(['0x', z.string().regex(/^[0-9a-fA-F]{40}$/)]);

package/dist/cli/commands/utils/show-prividium-header.d.ts

@@ -0,0 +1,2 @@
+export declare const HEADER = "             .__      .__    .___.__                               .__  .__ \n_____________|__|__  _|__| __| _/|__|__ __  _____             ____ |  | |__|\n\\____ \\_  __ \\  \\  \\/ /  |/ __ | |  |  |  \\/     \\   ______ _/ ___\\|  | |  |\n|  |_> >  | \\/  |\\   /|  / /_/ | |  |  |  /  Y Y  \\ /_____/ \\  \\___|  |_|  |\n|   __/|__|  |__| \\_/ |__\\____ | |__|____/|__|_|  /          \\___  >____/__|\n|__|                          \\/                \\/               \\/         ";
+export declare function showPrividiumHeader(): void;

package/dist/cli/commands/utils/url-config.d.ts

@@ -0,0 +1,18 @@
+type GatherApiUrlOptions = {
+    configPath?: string;
+    apiUrl?: string;
+    logProvidedUrls?: boolean;
+};
+export declare function gatherApiUrl({ configPath, apiUrl, logProvidedUrls }: GatherApiUrlOptions): Promise<string>;
+type GatherUrlConfigOptions = {
+    configPath?: string;
+    rpcUrl?: string;
+    rpcUrlLabel: string;
+    logProvidedUrls?: boolean;
+    userPanelUrl?: string;
+};
+export declare function gatherUrlConfig({ configPath, rpcUrl, userPanelUrl, rpcUrlLabel, logProvidedUrls }: GatherUrlConfigOptions): Promise<{
+    prividiumRpcUrl: string;
+    userPanelUrl: string;
+}>;
+export {};

package/dist/cli/commands/verify/account-data-cmd.d.ts

@@ -0,0 +1,14 @@
+import type { VerifyDefCommand } from '../verify.js';
+type Opts = {
+    address: string;
+    l1Rpc?: string;
+    apiUrl?: string;
+    blockNumber: string;
+    diamondAddress?: string;
+    configPath?: string;
+    expectedBytecode?: string;
+    verbose: boolean;
+};
+export declare function verifyAccountData(opts: Opts): Promise<void>;
+export declare const addVerifyAccountDataCmd: VerifyDefCommand;
+export {};

package/dist/cli/commands/verify/account-data-cmd.js

@@ -0,0 +1,102 @@
+import { selectiveDisclosureActions, verifyAccountPropertiesProof } from '@repo/prividium-sdk';
+import { createPublicClient, getAddress, http } from 'viem';
+import { ConfigFile } from '../../server/config-file.js';
+import { addressSchema } from '../utils/schemas.js';
+import { parseBlockNumber } from './utils.js';
+import { VerifyWorkflow } from './verify-workflow.js';
+export async function verifyAccountData(opts) {
+    const wf = new VerifyWorkflow();
+    const configFile = new ConfigFile(opts.configPath);
+    wf.start();
+    const givenAddressParsed = addressSchema.safeParse(opts.address);
+    if (!givenAddressParsed.success) {
+        wf.error(`Invalid address: ${opts.address}`);
+        process.exit(1);
+    }
+    if (opts.diamondAddress && !addressSchema.safeParse(opts.diamondAddress).success) {
+        wf.error(`Invalid diamond address: ${opts.diamondAddress}`);
+        process.exit(1);
+    }
+    const givenAddress = getAddress(givenAddressParsed.data);
+    try {
+        const { l1RpcUrl, diamondAddress, apiUrl } = await configFile.readAndUpdatedRequiredFields({
+            apiUrl: opts.apiUrl,
+            l1RpcUrl: opts.l1Rpc,
+            diamondAddress: opts.diamondAddress
+        });
+        const prividiumRpcUrl = new URL('/rpc', apiUrl).toString();
+        const l1Client = createPublicClient({ transport: http(l1RpcUrl) });
+        const prividiumRpc = createPublicClient({ transport: http(prividiumRpcUrl) }).extend(selectiveDisclosureActions);
+        const disclosure = await wf
+            .step('Gathering proofs', 'Proofs received ✅', () => prividiumRpc.accountDataDisclosure(givenAddress, 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 expectedBytecode = opts.expectedBytecode ? opts.expectedBytecode : undefined;
+        const res = await wf
+            .step('Verifying proofs', 'Proofs verified ✅', () => verifyAccountPropertiesProof(disclosure, l1Client, getAddress(diamondAddress), expectedBytecode, givenAddress))
+            .catch((e) => {
+            const detail = e instanceof Error ? e.message : 'unexpected error';
+            wf.error(`Unexpected error verifying proofs: ${detail}`);
+            process.exit(1);
+        });
+        if (res.success) {
+            [
+                `Address: ${getAddress(disclosure.address)}`,
+                `Balance: ${disclosure.accountProperties.balance}`,
+                `Nonce: ${disclosure.accountProperties.nonce}`,
+                `Bytecode: ${disclosure.bytecode}`
+            ].forEach((msg) => {
+                wf.message(msg);
+            });
+            wf.success('Ok!');
+        }
+        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 addVerifyAccountDataCmd = (cli) => cli.command('account-data <address>', 'Verify account data (balance, nonce, bytecode) using proofs from L1', (yargs) => yargs
+    .positional('address', {
+    description: 'Address of the account to verify',
+    type: 'string',
+    demandOption: true
+})
+    .option('expectedBytecode', {
+    alias: ['expected-bytecode', 'bytecode'],
+    description: 'Expected contract bytecode (hex). When provided, the verifier checks that the disclosed bytecode hash matches this value.',
+    demandOption: false,
+    type: 'string'
+})
+    .option('verbose', {
+    alias: ['v'],
+    description: 'Verbose',
+    type: 'boolean',
+    default: false
+}), async (yargs) => {
+    await verifyAccountData({
+        address: yargs.address,
+        l1Rpc: yargs.l1Rpc,
+        apiUrl: yargs.apiUrl,
+        blockNumber: yargs.blockNumber,
+        diamondAddress: yargs.diamondAddress,
+        configPath: yargs.configPath,
+        expectedBytecode: yargs.expectedBytecode,
+        verbose: yargs.verbose
+    });
+});

package/dist/cli/commands/verify/erc20-balance-cmd.d.ts

@@ -0,0 +1,17 @@
+import type { VerifyDefCommand } from '../verify.js';
+type Opts = {
+    tokenAddr: string;
+    holderAddr: string;
+    l1Rpc?: string;
+    zkSyncOsRpc?: string;
+    apiUrl?: string;
+    blockNumber: string;
+    diamondAddress?: string;
+    bytecodesFile?: string;
+    bytecodes: string[];
+    configPath?: string;
+    verbose: boolean;
+};
+export declare function erc20BalanceCmd(opts: Opts): Promise<void>;
+export declare const addErc20BalanceCmd: VerifyDefCommand;
+export {};

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

@@ -0,0 +1,111 @@
+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 erc20BalanceCmd(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 l2RpcUrl = localZksyncOsRpcUrl;
+        const prividiumRpcUrl = new URL('/rpc', apiUrl).toString();
+        const checkedTokenAddr = getAddress(opts.tokenAddr);
+        const checkedHolderAddr = getAddress(opts.holderAddr);
+        const l1Client = createPublicClient({ transport: http(l1RpcUrl) });
+        const l2Client = createPublicClient({ transport: http(l2RpcUrl) });
+        const prividiumRpc = createPublicClient({ transport: http(prividiumRpcUrl) }).extend(selectiveDisclosureActions);
+        const disclosure = await wf
+            .step('Gathering proofs', 'Proofs fetched ✅', () => prividiumRpc.tokenBalanceDisclosure(checkedTokenAddr, checkedHolderAddr, 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(`Balance: ${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 addErc20BalanceCmd = (cli) => cli.command('erc20-balance <tokenAddr> <holderAddr>', 'Verify an ERC-20 holder balance using proofs from L1', (yargs) => yargs
+    .positional('tokenAddr', {
+    description: 'Address of the token',
+    type: 'string',
+    demandOption: true
+})
+    .positional('holderAddr', {
+    description: 'Address of the token holder to check the balance',
+    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 erc20BalanceCmd({
+        tokenAddr: yargs.tokenAddr,
+        holderAddr: yargs.holderAddr,
+        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/erc20-supply-cmd.d.ts

@@ -0,0 +1,16 @@
+import type { VerifyDefCommand } from '../verify.js';
+type Opts = {
+    tokenAddr: string;
+    l1Rpc?: string;
+    zkSyncOsRpc?: string;
+    apiUrl?: string;
+    blockNumber: string;
+    diamondAddress?: string;
+    bytecodesFile?: string;
+    bytecodes: string[];
+    configPath?: string;
+    verbose: boolean;
+};
+export declare function erc20SupplyCmd(opts: Opts): Promise<void>;
+export declare const addErc20SupplyCmd: VerifyDefCommand;
+export {};