@aztec-labs/cli-wallet 6.0.0-nightly.20260829

package/dest/utils/wallet.d.ts

@@ -0,0 +1,64 @@
+import { type Account } from '@aztec-labs/aztec.js/account';
+import { type InteractionFeeOptions } from '@aztec-labs/aztec.js/contracts';
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import { AccountManager, type Aliased } from '@aztec-labs/aztec.js/wallet';
+import { TxSimulationResultWithAppOffset } from '@aztec-labs/aztec.js/wallet';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { NotesFilter } from '@aztec-labs/pxe/client/lazy';
+import type { PXEConfig } from '@aztec-labs/pxe/config';
+import type { PXE } from '@aztec-labs/pxe/server';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Gas, GasUsed } from '@aztec-labs/stdlib/gas';
+import { NoteDao } from '@aztec-labs/stdlib/note';
+import type { TxProvingResult } from '@aztec-labs/stdlib/tx';
+import { ExecutionPayload } from '@aztec-labs/stdlib/tx';
+import { BaseWallet, type SimulateViaEntrypointOptions } from '@aztec-labs/wallet-sdk/base-wallet';
+import type { WalletDB } from '../storage/wallet_db.js';
+import type { AccountType } from './constants.js';
+export declare class CLIWallet extends BaseWallet {
+    private userLog;
+    private db?;
+    private accountCache;
+    private stubClassIds;
+    constructor(pxe: PXE, node: AztecNode, userLog: LogFn, db?: WalletDB | undefined);
+    static create(node: AztecNode, log: LogFn, db?: WalletDB, overridePXEConfig?: Partial<PXEConfig>): Promise<CLIWallet>;
+    private registerAuthRegistry;
+    private initStubClasses;
+    getAccounts(): Promise<Aliased<AztecAddress>[]>;
+    /**
+     * Derives suggested total and teardown gas limits from simulated gas usage, padded and clamped to the
+     * network's per-tx admission limits.
+     * @param gasUsed - The gas consumed during simulation (from a `simulate({ includeMetadata: true })` result).
+     */
+    estimateGasLimits(gasUsed: GasUsed): Promise<{
+        gasLimits: Gas;
+        teardownGasLimits: Gas;
+    }>;
+    private createCancellationTxExecutionRequest;
+    proveCancellationTx(from: AztecAddress, txNonce: Fr, increasedFee: InteractionFeeOptions): Promise<TxProvingResult>;
+    getAccountFromAddress(address: AztecAddress): Promise<Account>;
+    /**
+     * Creates an account from freshly supplied keys. SSH accounts sign with a key held in the agent (resolved from
+     * `publicKey`), every other type is rooted on `signingKey`, with `secretKey` as its privacy secret.
+     */
+    createAccount(type: AccountType, signingKey: GrumpkinScalar | undefined, secretKey: Fr | undefined, salt?: Fr, publicKey?: string): Promise<AccountManager>;
+    /**
+     * Retrieves a previously stored account by address, loading its keys, type and salt from the wallet database.
+     */
+    retrieveAccount(address: AztecAddress): Promise<AccountManager>;
+    private buildAccount;
+    private resolveSshPublicSigningKey;
+    private materializeAccount;
+    private getFakeAccountDataFor;
+    /**
+     * Uses a stub account for kernelless simulation, bypassing real account authorization.
+     * Uses DefaultEntrypoint directly for NO_FROM transactions.
+     */
+    protected simulateViaEntrypoint(executionPayload: ExecutionPayload, opts: SimulateViaEntrypointOptions): Promise<TxSimulationResultWithAppOffset>;
+    getContracts(): Promise<AztecAddress[]>;
+    getNotes(filter: NotesFilter): Promise<NoteDao[]>;
+    getContractArtifact(id: Fr): Promise<import("@aztec-labs/stdlib/abi").ContractArtifact | undefined>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/utils/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/utils/wallet.ts"],"names":[],"mappings":"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"}

package/dest/utils/wallet.js

@@ -0,0 +1,285 @@
+import { EcdsaKAccountContract, EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec-labs/accounts/ecdsa';
+import { StubEcdsaAccountContractArtifact, createStubEcdsaAccount } from '@aztec-labs/accounts/ecdsa/stub';
+import { SchnorrAccountContract, SchnorrInitializerlessAccountContract } from '@aztec-labs/accounts/schnorr';
+import { StubSchnorrAccountContractArtifact, createStubSchnorrAccount } from '@aztec-labs/accounts/schnorr/stub';
+import { getIdentities } from '@aztec-labs/accounts/utils';
+import { NO_FROM } from '@aztec-labs/aztec.js/account';
+import { ContractFunctionInteraction, getContractClassFromArtifact } from '@aztec-labs/aztec.js/contracts';
+import { AccountManager } from '@aztec-labs/aztec.js/wallet';
+import { TxSimulationResultWithAppOffset } from '@aztec-labs/aztec.js/wallet';
+import { DefaultEntrypoint } from '@aztec-labs/entrypoints/default';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { createPXE, getPXEConfig } from '@aztec-labs/pxe/server';
+import { getStandardAuthRegistry } from '@aztec-labs/standard-contracts/auth-registry';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec-labs/stdlib/tx';
+import { BaseWallet, getGasLimits } from '@aztec-labs/wallet-sdk/base-wallet';
+import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
+/** Padding the CLI wallet applies to simulated gas usage when deriving declared gas limits. */ const DEFAULT_ESTIMATED_GAS_PADDING = 0.1;
+export class CLIWallet extends BaseWallet {
+    userLog;
+    db;
+    accountCache;
+    // Stub class ids, populated on wallet startup
+    // to avoid redundant work per simulation
+    stubClassIds;
+    constructor(pxe, node, userLog, db){
+        super(pxe, node), this.userLog = userLog, this.db = db, this.accountCache = new Map(), this.stubClassIds = new Map();
+        this.cancellableTransactions = true;
+    }
+    static async create(node, log, db, overridePXEConfig) {
+        const pxeConfig = Object.assign(getPXEConfig(), overridePXEConfig);
+        const pxe = await createPXE(node, pxeConfig);
+        const wallet = new CLIWallet(pxe, node, log, db);
+        await wallet.initStubClasses();
+        await wallet.registerAuthRegistry();
+        return wallet;
+    }
+    async registerAuthRegistry() {
+        const { instance, artifact } = await getStandardAuthRegistry();
+        await this.pxe.registerContractClass(artifact);
+        await this.pxe.registerContract(instance);
+    }
+    /**
+   * Hashes and registers the stub class for every supported account type with PXE, populating
+   * stubClassIds. Called on wallet initialization.
+   */ async initStubClasses() {
+        const { id: schnorrClassId } = await getContractClassFromArtifact(StubSchnorrAccountContractArtifact);
+        await this.pxe.registerContractClass(StubSchnorrAccountContractArtifact);
+        // ecdsa stubs share the same class id
+        const { id: ecdsaClassId } = await getContractClassFromArtifact(StubEcdsaAccountContractArtifact);
+        await this.pxe.registerContractClass(StubEcdsaAccountContractArtifact);
+        this.stubClassIds.set('schnorr', schnorrClassId);
+        this.stubClassIds.set('schnorr_initializerless', schnorrClassId);
+        this.stubClassIds.set('ecdsasecp256k1', ecdsaClassId);
+        this.stubClassIds.set('ecdsasecp256r1', ecdsaClassId);
+        this.stubClassIds.set('ecdsasecp256r1ssh', ecdsaClassId);
+    }
+    async getAccounts() {
+        const accounts = await this.db?.listAliases('accounts') ?? [];
+        return Promise.resolve(accounts.map(({ key, value })=>{
+            const alias = key.includes(':') ? key.slice(key.indexOf(':') + 1) : key;
+            return {
+                alias,
+                item: AztecAddress.fromStringUnsafe(value)
+            };
+        }));
+    }
+    /**
+   * Derives suggested total and teardown gas limits from simulated gas usage, padded and clamped to the
+   * network's per-tx admission limits.
+   * @param gasUsed - The gas consumed during simulation (from a `simulate({ includeMetadata: true })` result).
+   */ async estimateGasLimits(gasUsed) {
+        const maxTxGasLimits = await this.getMaxTxGasLimits();
+        return getGasLimits(gasUsed, maxTxGasLimits, DEFAULT_ESTIMATED_GAS_PADDING);
+    }
+    async createCancellationTxExecutionRequest(from, txNonce, increasedFee) {
+        const executionPayload = ExecutionPayload.empty();
+        const feeOptions = await this.completeFeeOptions({
+            from,
+            feePayer: executionPayload.feePayer,
+            gasSettings: increasedFee.gasSettings
+        });
+        const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+        const fromAccount = await this.getAccountFromAddress(from);
+        const chainInfo = await this.getChainInfo();
+        const executionOptions = {
+            txNonce,
+            cancellable: this.cancellableTransactions,
+            // If from is an address, feeOptions include the way the account contract should handle the fee payment
+            feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+        };
+        return await fromAccount.createTxExecutionRequest(feeExecutionPayload ?? executionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
+    }
+    async proveCancellationTx(from, txNonce, increasedFee) {
+        const cancellationTxRequest = await this.createCancellationTxExecutionRequest(from, txNonce, increasedFee);
+        return await this.pxe.proveTx(cancellationTxRequest, {
+            scopes: this.scopesFrom(from, [], undefined),
+            senderForTags: from
+        });
+    }
+    async getAccountFromAddress(address) {
+        let account;
+        if (this.accountCache.has(address.toString())) {
+            return this.accountCache.get(address.toString());
+        } else {
+            const accountManager = await this.retrieveAccount(address);
+            account = await accountManager.getAccount();
+        }
+        if (!account) {
+            throw new Error(`Account not found in wallet for address: ${address}`);
+        }
+        return account;
+    }
+    /**
+   * Creates an account from freshly supplied keys. SSH accounts sign with a key held in the agent (resolved from
+   * `publicKey`), every other type is rooted on `signingKey`, with `secretKey` as its privacy secret.
+   */ async createAccount(type, signingKey, secretKey, salt = Fr.ZERO, publicKey) {
+        const publicSigningKey = type === 'ecdsasecp256r1ssh' ? await this.resolveSshPublicSigningKey(publicKey) : undefined;
+        return this.buildAccount(type, salt, signingKey, secretKey, publicSigningKey);
+    }
+    /**
+   * Retrieves a previously stored account by address, loading its keys, type and salt from the wallet database.
+   */ async retrieveAccount(address) {
+        if (!this.db) {
+            throw new Error('Cannot retrieve an account without a wallet database');
+        }
+        const { type, signingKey, secretKey, salt } = await this.db.retrieveAccount(address);
+        if (type !== 'ecdsasecp256r1ssh' && !signingKey) {
+            throw new Error(`Account ${address} has no stored signing key: it was created with an older version of aztec-wallet and is ` + `incompatible with this one. Create a new account to continue.`);
+        }
+        const publicSigningKey = type === 'ecdsasecp256r1ssh' ? await this.db.retrieveAccountMetadata(address, 'publicSigningKey') : undefined;
+        return this.buildAccount(type, salt, signingKey, secretKey, publicSigningKey);
+    }
+    async buildAccount(type, salt, signingKey, secretKey, publicSigningKey) {
+        switch(type){
+            case 'schnorr':
+            case 'schnorr_initializerless':
+            case 'ecdsasecp256r1':
+            case 'ecdsasecp256k1':
+                {
+                    if (!signingKey || !secretKey) {
+                        throw new Error('Cannot build account without signing key and secret key');
+                    }
+                    const contract = type === 'schnorr' ? new SchnorrAccountContract(signingKey) : type === 'schnorr_initializerless' ? new SchnorrInitializerlessAccountContract(signingKey) : type === 'ecdsasecp256r1' ? new EcdsaRAccountContract(signingKey.toBuffer()) : new EcdsaKAccountContract(signingKey.toBuffer());
+                    return await this.materializeAccount(secretKey, salt, contract);
+                }
+            case 'ecdsasecp256r1ssh':
+                {
+                    if (!secretKey || !publicSigningKey) {
+                        throw new Error('Cannot build SSH account without secret key and public signing key');
+                    }
+                    return await this.materializeAccount(secretKey, salt, new EcdsaRSSHAccountContract(publicSigningKey));
+                }
+            default:
+                {
+                    throw new Error(`Unsupported account type: ${type}`);
+                }
+        }
+    }
+    async resolveSshPublicSigningKey(publicKey) {
+        if (!publicKey) {
+            throw new Error('Public key must be provided for ECDSA SSH account');
+        }
+        const identities = await getIdentities();
+        const foundIdentity = identities.find((identity)=>identity.type === 'ecdsa-sha2-nistp256' && identity.publicKey === publicKey);
+        if (!foundIdentity) {
+            throw new Error(`Identity for public key ${publicKey} not found in the SSH agent`);
+        }
+        return extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
+    }
+    async materializeAccount(secret, salt, contract) {
+        const accountManager = await AccountManager.create(this, secret, contract, {
+            salt
+        });
+        const instance = accountManager.getInstance();
+        const artifact = await contract.getContractArtifact();
+        await this.registerContract(instance, artifact, secret);
+        this.accountCache.set(accountManager.address.toString(), await accountManager.getAccount());
+        // Initializerless accounts have no deployment tx; their address commits to the signing public key
+        // (via the contract's immutablesHash, resolved by AccountManager.create) and the constructor's
+        // storage writes are materialized locally via a simulated "store" call here.
+        if (contract instanceof SchnorrInitializerlessAccountContract) {
+            const constructorAbi = artifact.functions.find((f)=>f.name === 'constructor');
+            if (!constructorAbi) {
+                throw new Error('Could not create SchnorrInitializerlessAccount: constructor ABI not found');
+            }
+            const { x, y } = await contract.getSigningPublicKey();
+            const storeCall = new ContractFunctionInteraction(this, instance.address, constructorAbi, [
+                x,
+                y
+            ]);
+            await storeCall.simulate({
+                from: instance.address
+            });
+        }
+        return accountManager;
+    }
+    /**
+   * Creates a stub account that impersonates the given address, allowing kernelless simulations
+   * to bypass the account's authorization mechanisms via contract overrides.
+   * @param address - The address of the account to impersonate
+   * @returns The stub account, contract instance, and artifact for simulation
+   */ async getFakeAccountDataFor(address) {
+        const originalAccount = await this.getAccountFromAddress(address);
+        const originalAddress = originalAccount.getCompleteAddress();
+        const contractInstance = await this.pxe.getContractInstance(originalAddress.address);
+        if (!contractInstance) {
+            throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+        }
+        const { type } = await this.db.retrieveAccount(address);
+        const stubAccount = type === 'schnorr' || type === 'schnorr_initializerless' ? createStubSchnorrAccount(originalAddress) : createStubEcdsaAccount(originalAddress);
+        const stubClassId = this.stubClassIds.get(type);
+        if (!stubClassId) {
+            throw new Error(`Stub class for account type '${type}' was not registered at wallet init. This is a bug — initStubClasses should cover every supported AccountType.`);
+        }
+        const instance = {
+            ...contractInstance,
+            currentContractClassId: stubClassId
+        };
+        return {
+            account: stubAccount,
+            instance
+        };
+    }
+    /**
+   * Uses a stub account for kernelless simulation, bypassing real account authorization.
+   * Uses DefaultEntrypoint directly for NO_FROM transactions.
+   */ async simulateViaEntrypoint(executionPayload, opts) {
+        const { from, feeOptions, additionalScopes, sendMessagesAs } = opts;
+        const scopes = this.scopesFrom(from, additionalScopes ?? [], sendMessagesAs);
+        const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+        const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
+            feeExecutionPayload,
+            executionPayload
+        ]) : executionPayload;
+        const chainInfo = await this.getChainInfo();
+        let overrides;
+        let txRequest;
+        if (from === NO_FROM) {
+            const entrypoint = new DefaultEntrypoint();
+            txRequest = await entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
+        } else {
+            const { account, instance } = await this.getFakeAccountDataFor(from);
+            overrides = {
+                contracts: {
+                    [from.toString()]: {
+                        instance
+                    }
+                }
+            };
+            const executionOptions = {
+                txNonce: Fr.random(),
+                cancellable: this.cancellableTransactions,
+                // If from is an address, feeOptions include the way the account contract should handle the fee payment
+                feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+            };
+            txRequest = await account.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
+        }
+        const result = await this.pxe.simulateTx(txRequest, {
+            simulatePublic: true,
+            skipFeeEnforcement: true,
+            skipTxValidation: true,
+            overrides,
+            scopes,
+            senderForTags: this.senderForTagsFrom(from, sendMessagesAs)
+        });
+        const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
+        return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
+    }
+    // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+    // this is just a CLI wallet.
+    getContracts() {
+        return this.pxe.getContracts();
+    }
+    // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+    // this is just a CLI wallet.
+    getNotes(filter) {
+        return this.pxe.debug.getNotes(filter);
+    }
+    // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+    // this is just a CLI wallet.
+    getContractArtifact(id) {
+        return this.pxe.getContractArtifact(id);
+    }
+}

package/dest/utils/well_known_contracts.d.ts

@@ -0,0 +1,8 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { WalletDB } from '../storage/wallet_db.js';
+/**
+ * Aliases the well-known contracts missing from the wallet's database. Contracts that already have an alias are
+ * skipped, so a user's own alias survives and older databases pick up new entries.
+ */
+export declare function registerWellKnownContractAliases(db: WalletDB, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2VsbF9rbm93bl9jb250cmFjdHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy93ZWxsX2tub3duX2NvbnRyYWN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUl4RCxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUV4RDs7O0dBR0c7QUFDSCx3QkFBc0IsZ0NBQWdDLENBQUMsRUFBRSxFQUFFLFFBQVEsRUFBRSxHQUFHLEVBQUUsS0FBSyxpQkFTOUUifQ==

package/dest/utils/well_known_contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"well_known_contracts.d.ts","sourceRoot":"","sources":["../../src/utils/well_known_contracts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAIxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD;;;GAGG;AACH,wBAAsB,gCAAgC,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,iBAS9E"}

package/dest/utils/well_known_contracts.js

@@ -0,0 +1,38 @@
+import { ProtocolContractAddress } from '@aztec-labs/aztec.js/protocol';
+import { getSponsoredFPCAddress } from '@aztec-labs/cli/cli-utils';
+import { StandardContractAddress } from '@aztec-labs/standard-contracts/data';
+/**
+ * Aliases the well-known contracts missing from the wallet's database. Contracts that already have an alias are
+ * skipped, so a user's own alias survives and older databases pick up new entries.
+ */ export async function registerWellKnownContractAliases(db, log) {
+    for (const { name, getAddress } of wellKnownContracts){
+        if (await hasAlias(db, `contracts:${name}`)) {
+            continue;
+        }
+        const address = (await getAddress()).toString();
+        await db.storeAlias('contracts', name, Buffer.from(address), log);
+        await db.storeAlias('artifacts', address, Buffer.from(name), log);
+    }
+}
+const wellKnownContracts = [
+    ...Object.entries({
+        ...ProtocolContractAddress,
+        ...StandardContractAddress
+    }).map(([name, address])=>({
+            name,
+            getAddress: ()=>address
+        })),
+    // SponsoredFPC has no generated address record: it is instantiated with a zero salt, so its address is computed
+    // from the current artifact.
+    {
+        name: 'SponsoredFPC',
+        getAddress: getSponsoredFPCAddress
+    }
+];
+async function hasAlias(db, alias) {
+    try {
+        return !!await db.retrieveAlias(alias);
+    } catch  {
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@aztec-labs/cli-wallet",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    ".": "./dest/cmds/index.js",
+    "./cli": "./dest/bin/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/cmds/index.ts"
+    ],
+    "name": "Aztec CLI wallet",
+    "tsconfig": "./tsconfig.json"
+  },
+  "bin": {
+    "aztec-wallet": "./dest/bin/index.js"
+  },
+  "scripts": {
+    "start": "node --no-warnings ./dest/bin",
+    "start:debug": "node --inspect=0.0.0.0:9221 --no-warnings ./dest/bin",
+    "dev": "LOG_LEVEL=\"debug; info: json-rpc, simulator\" node ./dest/bin",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "preset": "ts-jest/presets/default-esm",
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec-labs/accounts": "6.0.0-nightly.20260829",
+    "@aztec-labs/aztec.js": "6.0.0-nightly.20260829",
+    "@aztec-labs/cli": "6.0.0-nightly.20260829",
+    "@aztec-labs/entrypoints": "6.0.0-nightly.20260829",
+    "@aztec-labs/ethereum": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/kv-store": "6.0.0-nightly.20260829",
+    "@aztec-labs/pxe": "6.0.0-nightly.20260829",
+    "@aztec-labs/standard-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "@aztec-labs/wallet-sdk": "6.0.0-nightly.20260829",
+    "@aztec/bb.js": "6.0.0-nightly.20260826",
+    "commander": "^12.1.0",
+    "inquirer": "^10.1.8",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "@types/source-map-support": "^0.5.10",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/bin/index.ts

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { BackendType, Barretenberg } from '@aztec/bb.js';
+
+import { computeSecretHash } from '@aztec-labs/aztec.js/crypto';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import { createAztecNodeClient } from '@aztec-labs/aztec.js/node';
+import { LOCALHOST } from '@aztec-labs/cli/cli-utils';
+import { type LogFn, createConsoleLogger, createLogger } from '@aztec-labs/foundation/log';
+import { openStoreAt } from '@aztec-labs/kv-store/lmdb-v2';
+import type { PXEConfig } from '@aztec-labs/pxe/config';
+import { getPackageVersion } from '@aztec-labs/stdlib/update-checker';
+import { Argument, Command, Option } from 'commander';
+import { homedir } from 'os';
+import { join } from 'path';
+
+import { injectCommands } from '../cmds/index.js';
+import { Aliases, WalletDB } from '../storage/wallet_db.js';
+import { CliWalletAndNodeWrapper } from '../utils/cli_wallet_and_node_wrapper.js';
+import { createAliasOption } from '../utils/options/index.js';
+import { CLIWallet } from '../utils/wallet.js';
+import { registerWellKnownContractAliases } from '../utils/well_known_contracts.js';
+
+const userLog = createConsoleLogger();
+const debugLogger = createLogger('wallet');
+
+const { WALLET_DATA_DIRECTORY = join(homedir(), '.aztec/wallet') } = process.env;
+
+// TODO: This function is only used in 1 place so we could just inline this
+function injectInternalCommands(program: Command, log: LogFn, db: WalletDB) {
+  program
+    .command('alias')
+    .description('Aliases information for easy reference.')
+    .addArgument(new Argument('<type>', 'Type of alias to create').choices(Aliases))
+    .argument('<key>', 'Key to alias.')
+    .argument('<value>', 'Value to assign to the alias.')
+    .action(async (type, key, value) => {
+      value = db.tryRetrieveAlias(value) || value;
+      await db.storeAlias(type, key, value, log);
+    });
+
+  program
+    .command('get-alias')
+    .description('Shows stored aliases')
+    .addArgument(new Argument('[alias]', 'Alias to retrieve'))
+    .action(async alias => {
+      if (alias?.includes(':')) {
+        const value = await db.retrieveAlias(alias);
+        log(value);
+      } else {
+        const aliases = await db.listAliases(alias);
+        for (const { key, value } of aliases) {
+          log(`${key} -> ${value}`);
+        }
+      }
+    });
+
+  program
+    .command('create-secret')
+    .description('Creates an aliased secret to use in other commands')
+    .addOption(createAliasOption('Key to alias the secret with', false).makeOptionMandatory(true))
+    .action(async (_options, command) => {
+      const options = command.optsWithGlobals();
+      const { alias } = options;
+      const value = Fr.random();
+      const hash = await computeSecretHash(value);
+
+      await db.storeAlias('secrets', alias, Buffer.from(value.toString()), log);
+      await db.storeAlias('secrets', `${alias}:hash`, Buffer.from(hash.toString()), log);
+    });
+
+  return program;
+}
+
+/** CLI wallet main entrypoint */
+async function main() {
+  const walletVersion = getPackageVersion();
+
+  const db = WalletDB.getInstance();
+  const walletAndNodeWrapper = new CliWalletAndNodeWrapper();
+
+  const program = new Command('wallet');
+  program
+    .description('Aztec wallet')
+    .version(walletVersion)
+    .option('-d, --data-dir <string>', 'Storage directory for wallet data', WALLET_DATA_DIRECTORY)
+    .addOption(
+      new Option('-p, --prover <string>', 'The type of prover the wallet uses')
+        .choices(['wasm', 'native', 'none'])
+        .env('PXE_PROVER')
+        .default('native'),
+    )
+    .addOption(
+      new Option('-n, --node-url <string>', 'URL of the Aztec node to connect to')
+        .env('AZTEC_NODE_URL')
+        .default(`http://${LOCALHOST}:8080`),
+    )
+    .hook('preSubcommand', async command => {
+      // Skip initialization if user is just requesting help
+      if (command.args.includes('--help') || command.args.includes('-h')) {
+        return;
+      }
+
+      const { dataDir, nodeUrl, prover } = command.optsWithGlobals();
+
+      const proverEnabled = prover !== 'none';
+
+      switch (prover) {
+        case 'native':
+          await Barretenberg.initSingleton({ backend: BackendType.NativeUnixSocket });
+          break;
+        case 'wasm':
+          await Barretenberg.initSingleton({ backend: BackendType.Wasm });
+          break;
+      }
+
+      const overridePXEConfig: Partial<PXEConfig> = {
+        proverEnabled,
+        dataDirectory: join(dataDir, 'pxe'),
+      };
+
+      const node = createAztecNodeClient(nodeUrl);
+      const wallet = await CLIWallet.create(node, userLog, db, overridePXEConfig);
+
+      walletAndNodeWrapper.setNodeAndWallet(node, wallet);
+
+      await db.init(await openStoreAt(dataDir));
+      await registerWellKnownContractAliases(db, userLog);
+    });
+
+  injectCommands(program, userLog, debugLogger, walletAndNodeWrapper, db);
+  injectInternalCommands(program, userLog, db);
+  await program.parseAsync(process.argv);
+
+  await Barretenberg.destroySingleton();
+}
+
+main().catch(err => {
+  debugLogger.error(`Error in command execution`);
+  debugLogger.error(err + '\n' + err.stack);
+  process.exit(1);
+});