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

package/README.md

@@ -0,0 +1,32 @@
+# Aztec wallet Documentation
+
+### Run tests locally
+
+1) Start a local Ethereum node (Anvil) in one terminal:
+
+```bash
+anvil --host 127.0.0.1 --port 8545
+```
+
+2) In another terminal, start the Aztec local network from `yarn-project/aztec`:
+
+```bash
+cd yarn-project/aztec
+NODE_NO_WARNINGS=1 ETHEREUM_HOSTS=http://127.0.0.1:8545 node ./dest/bin/index.js start --local-network
+```
+
+3) Run the wallet tests from `yarn-project/cli-wallet/test`:
+
+```bash
+cd yarn-project/cli-wallet/test
+./test.sh --filter <partialnameoftest>
+```
+
+Notes:
+- **Filter tests**: Omit `--filter` to run all tests, or pass part of a test filename to run a subset.
+- **Docker mode**: You can run tests using Docker by adding `--docker`:
+
+```bash
+./test.sh --docker --filter <partialnameoftest>
+```
+

package/dest/bin/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/bin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":""}

package/dest/bin/index.js

@@ -0,0 +1,96 @@
+#!/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 { createConsoleLogger, createLogger } from '@aztec-labs/foundation/log';
+import { openStoreAt } from '@aztec-labs/kv-store/lmdb-v2';
+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, log, db) {
+    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 = {
+            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);
+});

package/dest/cmds/authorize_action.d.ts

@@ -0,0 +1,5 @@
+import type { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import type { Wallet } from '@aztec-labs/aztec.js/wallet';
+import type { LogFn } from '@aztec-labs/foundation/log';
+export declare function authorizeAction(wallet: Wallet, from: AztecAddress, functionName: string, caller: AztecAddress, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, log: LogFn): Promise<import("@aztec-labs/aztec.js/contracts").TxSendResultMined<import("@aztec-labs/stdlib/tx").TxReceipt>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaXplX2FjdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NtZHMvYXV0aG9yaXplX2FjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUduRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUxRCxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUl4RCx3QkFBc0IsZUFBZSxDQUNuQyxNQUFNLEVBQUUsTUFBTSxFQUNkLElBQUksRUFBRSxZQUFZLEVBQ2xCLFlBQVksRUFBRSxNQUFNLEVBQ3BCLE1BQU0sRUFBRSxZQUFZLEVBQ3BCLGNBQWMsRUFBRSxHQUFHLEVBQUUsRUFDckIsb0JBQW9CLEVBQUUsTUFBTSxFQUM1QixlQUFlLEVBQUUsWUFBWSxFQUM3QixHQUFHLEVBQUUsS0FBSyxrSEE2QlgifQ==

package/dest/cmds/authorize_action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize_action.d.ts","sourceRoot":"","sources":["../../src/cmds/authorize_action.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAGnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAIxD,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,YAAY,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,GAAG,EAAE,KAAK,kHA6BX"}

package/dest/cmds/authorize_action.js

@@ -0,0 +1,23 @@
+import { SetPublicAuthwitContractInteraction } from '@aztec-labs/aztec.js/authorization';
+import { Contract } from '@aztec-labs/aztec.js/contracts';
+import { prepTx } from '@aztec-labs/cli/utils';
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+export async function authorizeAction(wallet, from, functionName, caller, functionArgsIn, contractArtifactPath, contractAddress, log) {
+    const { functionArgs, contractArtifact, isPrivate } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+    if (isPrivate) {
+        throw new Error('Cannot authorize private function. To allow a third party to call a private function, please create an authorization witness via the create-authwit command');
+    }
+    const contract = Contract.at(contractAddress, contractArtifact, wallet);
+    const action = contract.methods[functionName](...functionArgs);
+    const setAuthwitnessInteraction = await SetPublicAuthwitContractInteraction.create(wallet, from, {
+        caller,
+        action
+    }, true);
+    const witness = await setAuthwitnessInteraction.send({
+        wait: {
+            timeout: DEFAULT_TX_TIMEOUT_S
+        }
+    });
+    log(`Authorized action ${functionName} on contract ${contractAddress} for caller ${caller}`);
+    return witness;
+}

package/dest/cmds/bridge_fee_juice.d.ts

@@ -0,0 +1,6 @@
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+export declare function bridgeL1FeeJuice(amount: bigint, recipient: AztecAddress, node: AztecNode, l1RpcUrls: string[], chainId: number, privateKey: string | undefined, mnemonic: string, mint: boolean, json: boolean, wait: boolean, interval: number | undefined, log: LogFn, debugLogger: Logger): Promise<readonly [Fr, bigint]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJpZGdlX2ZlZV9qdWljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NtZHMvYnJpZGdlX2ZlZV9qdWljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUszRCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBR3JFLHdCQUFzQixnQkFBZ0IsQ0FDcEMsTUFBTSxFQUFFLE1BQU0sRUFDZCxTQUFTLEVBQUUsWUFBWSxFQUN2QixJQUFJLEVBQUUsU0FBUyxFQUNmLFNBQVMsRUFBRSxNQUFNLEVBQUUsRUFDbkIsT0FBTyxFQUFFLE1BQU0sRUFDZixVQUFVLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDOUIsUUFBUSxFQUFFLE1BQU0sRUFDaEIsSUFBSSxFQUFFLE9BQU8sRUFDYixJQUFJLEVBQUUsT0FBTyxFQUNiLElBQUksRUFBRSxPQUFPLEVBQ2IsUUFBUSxvQkFBUyxFQUNqQixHQUFHLEVBQUUsS0FBSyxFQUNWLFdBQVcsRUFBRSxNQUFNLGtDQW1FcEIifQ==

package/dest/cmds/bridge_fee_juice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge_fee_juice.d.ts","sourceRoot":"","sources":["../../src/cmds/bridge_fee_juice.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAK3D,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGrE,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,YAAY,EACvB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,EACb,QAAQ,oBAAS,EACjB,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,kCAmEpB"}

package/dest/cmds/bridge_fee_juice.js

@@ -0,0 +1,54 @@
+import { L1FeeJuicePortalManager } from '@aztec-labs/aztec.js/ethereum';
+import { ProtocolContractAddress } from '@aztec-labs/aztec.js/protocol';
+import { prettyPrintJSON } from '@aztec-labs/cli/utils';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { createExtendedL1Client } from '@aztec-labs/ethereum/client';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { getNonNullifiedL1ToL2MessageWitness } from '@aztec-labs/stdlib/messaging';
+export async function bridgeL1FeeJuice(amount, recipient, node, l1RpcUrls, chainId, privateKey, mnemonic, mint, json, wait, interval = 60_000, log, debugLogger) {
+    // Prepare L1 client
+    const chain = createEthereumChain(l1RpcUrls, chainId);
+    const client = createExtendedL1Client(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+    // Setup portal manager
+    const portal = await L1FeeJuicePortalManager.new(node, client, debugLogger);
+    const { claimAmount, claimSecret, messageHash, messageLeafIndex } = await portal.bridgeTokensPublic(recipient, amount, mint);
+    if (json) {
+        const out = {
+            claimAmount,
+            claimSecret,
+            messageLeafIndex
+        };
+        log(prettyPrintJSON(out));
+    } else {
+        if (mint) {
+            log(`Minted ${claimAmount} fee juice on L1 and pushed to L2 portal`);
+        } else {
+            log(`Bridged ${claimAmount} fee juice to L2 portal`);
+        }
+        log(`claimAmount=${claimAmount},claimSecret=${claimSecret},messageHash=${messageHash},messageLeafIndex=${messageLeafIndex}\n`);
+        log(`Note: You need to wait for two L2 blocks before pulling them from the L2 side`);
+        if (wait) {
+            log(`This command will now continually poll every ${interval / 1000}s for the inclusion of the newly created L1 to L2 message`);
+        }
+    }
+    if (wait) {
+        const delayedCheck = (delay)=>{
+            return new Promise((resolve, reject)=>{
+                setTimeout(()=>{
+                    void getNonNullifiedL1ToL2MessageWitness(node, ProtocolContractAddress.FeeJuice, Fr.fromHexString(messageHash), claimSecret).then((witness)=>resolve(witness)).catch((err)=>reject(err));
+                }, delay);
+            });
+        };
+        let witness;
+        while(!witness){
+            witness = await delayedCheck(interval);
+            if (!witness) {
+                log(`No L1 to L2 message found yet, checking again in ${interval / 1000}s`);
+            }
+        }
+    }
+    return [
+        claimSecret,
+        messageLeafIndex
+    ];
+}

package/dest/cmds/check_tx.d.ts

@@ -0,0 +1,6 @@
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import type { TxHash } from '@aztec-labs/aztec.js/tx';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { CLIWallet } from '../utils/wallet.js';
+export declare function checkTx(wallet: CLIWallet, aztecNode: AztecNode, txHash: TxHash, statusOnly: boolean, log: LogFn): Promise<import("@aztec-labs/aztec.js/tx").TxStatus | undefined>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tfdHguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbWRzL2NoZWNrX3R4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRTNELE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3RELE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBUXhELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELHdCQUFzQixPQUFPLENBQzNCLE1BQU0sRUFBRSxTQUFTLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsVUFBVSxFQUFFLE9BQU8sRUFDbkIsR0FBRyxFQUFFLEtBQUssbUVBUVgifQ==

package/dest/cmds/check_tx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_tx.d.ts","sourceRoot":"","sources":["../../src/cmds/check_tx.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAQxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wBAAsB,OAAO,CAC3B,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,OAAO,EACnB,GAAG,EAAE,KAAK,mEAQX"}

package/dest/cmds/check_tx.js

@@ -0,0 +1,181 @@
+import { ProtocolContractAddress } from '@aztec-labs/aztec.js/protocol';
+import { computeSiloedPrivateInitializationNullifier, computeSiloedPublicInitializationNullifier, siloNullifier } from '@aztec-labs/stdlib/hash';
+export async function checkTx(wallet, aztecNode, txHash, statusOnly, log) {
+    if (statusOnly) {
+        const receipt = await aztecNode.getTxReceipt(txHash);
+        return receipt.status;
+    } else {
+        await inspectTx(wallet, aztecNode, txHash, log);
+    }
+}
+// The rest of the code here was copied over here from CLI because in CLI I needed to prune the inspect function of the PXE
+// dependency when dropping PXE JSON RPC Server.
+async function inspectTx(wallet, aztecNode, txHash, log) {
+    const receipt = await aztecNode.getTxReceipt(txHash, {
+        includeTxEffect: true
+    });
+    // Base tx data
+    log(`Tx ${txHash.toString()}`);
+    log(` Status: ${receipt.status}`);
+    if (receipt.executionResult) {
+        log(` Execution result: ${receipt.executionResult}`);
+    }
+    if (receipt.error) {
+        log(` Error: ${receipt.error}`);
+    }
+    if (!receipt.isMined() || !receipt.txEffect) {
+        return;
+    }
+    const effects = receipt.txEffect;
+    const artifactMap = await getKnownArtifacts(wallet);
+    log(` Block: ${receipt.blockNumber} (${receipt.blockHash?.toString()})`);
+    if (receipt.transactionFee) {
+        log(` Fee: ${receipt.transactionFee.toString()}`);
+    }
+    // Public logs
+    const publicLogs = effects.publicLogs;
+    if (publicLogs.length > 0) {
+        log(' Logs:');
+        for (const publicLog of publicLogs){
+            log(`  ${publicLog.toHumanReadable()}`);
+        }
+    }
+    // Public data writes
+    const writes = effects.publicDataWrites;
+    if (writes.length > 0) {
+        log(' Public data writes:');
+        for (const write of writes){
+            log(`  Leaf ${write.leafSlot.toString()} = ${write.value.toString()}`);
+        }
+    }
+    // Created notes
+    const notes = effects.noteHashes;
+    if (notes.length > 0) {
+        log(' Created notes:');
+        log(`  Total: ${notes.length}`);
+        for (const note of notes){
+            log(`  Note hash: ${note.toShortString()}`);
+        }
+    }
+    // Nullifiers
+    const nullifierCount = effects.nullifiers.length;
+    const { deployNullifiers, initNullifiers, classNullifiers } = await getKnownNullifiers(wallet, artifactMap);
+    const accounts = (await wallet.getAccounts()).map((a)=>a.item);
+    if (nullifierCount > 0) {
+        log(' Nullifiers:');
+        for (const nullifier of effects.nullifiers){
+            const deployed = deployNullifiers[nullifier.toString()];
+            const note = deployed ? (await wallet.getNotes({
+                siloedNullifier: nullifier,
+                contractAddress: deployed,
+                scopes: accounts
+            }))[0] : undefined;
+            const initialized = initNullifiers[nullifier.toString()];
+            const registered = classNullifiers[nullifier.toString()];
+            if (nullifier.toBuffer().equals(txHash.toBuffer())) {
+                log(`  Transaction hash nullifier ${nullifier.toShortString()}`);
+            } else if (note) {
+                inspectNote(note, artifactMap, log, `Nullifier ${nullifier.toShortString()} for note`);
+            } else if (deployed) {
+                log(`  Contract ${toFriendlyAddress(deployed, artifactMap)} deployed via nullifier ${nullifier.toShortString()}`);
+            } else if (initialized) {
+                log(`  Contract ${toFriendlyAddress(initialized, artifactMap)} initialized via nullifier ${nullifier.toShortString()}`);
+            } else if (registered) {
+                log(`  Class ${registered} registered via nullifier ${nullifier.toShortString()}`);
+            } else {
+                log(`  Unknown nullifier ${nullifier.toString()}`);
+            }
+        }
+    }
+    // L2 to L1 messages
+    if (effects.l2ToL1Msgs.length > 0) {
+        log(` L2 to L1 messages:`);
+        for (const msg of effects.l2ToL1Msgs){
+            log(`  ${msg.toString()}`);
+        }
+    }
+}
+function inspectNote(note, artifactMap, log, text = 'Note') {
+    const artifact = artifactMap[note.contractAddress.toString()];
+    const contract = artifact?.name ?? note.contractAddress.toString();
+    log(`  ${text} at ${contract}`);
+    for (const field of note.note.items){
+        log(`    ${field.toString()}`);
+    }
+}
+function toFriendlyAddress(address, artifactMap) {
+    const artifact = artifactMap[address.toString()];
+    if (!artifact) {
+        return address.toString();
+    }
+    return `${artifact.name}<${address.toString()}>`;
+}
+async function getKnownNullifiers(wallet, artifactMap) {
+    const knownContracts = await wallet.getContracts();
+    const [contractResults, classResults] = await Promise.all([
+        Promise.all(knownContracts.map((contract)=>getContractNullifiers(wallet, contract))),
+        Promise.all(Object.values(artifactMap).map((artifact)=>getClassNullifier(artifact)))
+    ]);
+    const initNullifiers = {};
+    const deployNullifiers = {};
+    const classNullifiers = {};
+    for (const { contract, deployNullifier, privateInitNullifier, publicInitNullifier } of contractResults){
+        deployNullifiers[deployNullifier.toString()] = contract;
+        if (privateInitNullifier) {
+            initNullifiers[privateInitNullifier.toString()] = contract;
+        }
+        initNullifiers[publicInitNullifier.toString()] = contract;
+    }
+    for (const { nullifier, label } of classResults){
+        classNullifiers[nullifier.toString()] = label;
+    }
+    return {
+        initNullifiers,
+        deployNullifiers,
+        classNullifiers
+    };
+}
+async function getContractNullifiers(wallet, contract) {
+    const deployerAddress = ProtocolContractAddress.ContractInstanceRegistry;
+    const deployNullifier = await siloNullifier(deployerAddress, contract.toField());
+    const metadata = await wallet.getContractMetadata(contract);
+    const privateInitNullifier = metadata.instance ? await computeSiloedPrivateInitializationNullifier(contract, metadata.instance.initializationHash) : undefined;
+    const publicInitNullifier = await computeSiloedPublicInitializationNullifier(contract);
+    return {
+        contract,
+        deployNullifier,
+        privateInitNullifier,
+        publicInitNullifier
+    };
+}
+async function getClassNullifier(artifact) {
+    const classRegistryAddress = ProtocolContractAddress.ContractClassRegistry;
+    const nullifier = await siloNullifier(classRegistryAddress, artifact.classId);
+    return {
+        nullifier,
+        label: `${artifact.name}Class<${artifact.classId}>`
+    };
+}
+async function getKnownArtifacts(wallet) {
+    const knownContractAddresses = await wallet.getContracts();
+    const knownContracts = await Promise.all(knownContractAddresses.map((contractAddress)=>wallet.getContractMetadata(contractAddress)));
+    const classIdFor = (metadata)=>metadata.updatedContractClassId ?? metadata.instance?.originalContractClassId;
+    const classIds = [
+        ...new Set(knownContracts.map(classIdFor))
+    ];
+    const knownArtifacts = (await Promise.all(classIds.map((classId)=>classId ? wallet.getContractArtifact(classId) : undefined))).map((artifact, index)=>artifact ? {
+            ...artifact,
+            classId: classIds[index]
+        } : undefined);
+    const map = {};
+    for (const metadata of knownContracts){
+        const classId = classIdFor(metadata);
+        if (metadata.instance && classId) {
+            const artifact = knownArtifacts.find((a)=>a?.classId?.equals(classId));
+            if (artifact) {
+                map[metadata.instance.address.toString()] = artifact;
+            }
+        }
+    }
+    return map;
+}

package/dest/cmds/create_account.d.ts

@@ -0,0 +1,17 @@
+import { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import { type AztecNode } from '@aztec-labs/aztec.js/node';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import { TxStatus } from '@aztec-labs/stdlib/tx';
+import type { AccountType } from '../utils/constants.js';
+import { CLIFeeArgs } from '../utils/options/fees.js';
+import { CLIWallet } from '../utils/wallet.js';
+export declare function createAccount(wallet: CLIWallet, aztecNode: AztecNode, accountType: AccountType, signingKey: GrumpkinScalar | undefined, salt: Fr | undefined, publicKey: string | undefined, alias: string | undefined, deployer: AztecAddress | undefined, registerOnly: boolean, skipInitialization: boolean, publicDeploy: boolean, registerClass: boolean, wait: boolean, feeOpts: CLIFeeArgs, waitForStatus: TxStatus, json: boolean, verbose: boolean, debugLogger: Logger, log: LogFn): Promise<{
+    alias: string | undefined;
+    address: AztecAddress;
+    signingKey: import("@aztec-labs/foundation/curves/bn254").Fq | undefined;
+    secretKey: Fr;
+    salt: Fr;
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlX2FjY291bnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbWRzL2NyZWF0ZV9hY2NvdW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUU5RCxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWEsTUFBTSwyQkFBMkIsQ0FBQztBQUd0RSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDekQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ3hFLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNoRSxPQUFPLEVBQStCLFFBQVEsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRzlFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3pELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUV0RCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFL0Msd0JBQXNCLGFBQWEsQ0FDakMsTUFBTSxFQUFFLFNBQVMsRUFDakIsU0FBUyxFQUFFLFNBQVMsRUFDcEIsV0FBVyxFQUFFLFdBQVcsRUFDeEIsVUFBVSxFQUFFLGNBQWMsR0FBRyxTQUFTLEVBQ3RDLElBQUksRUFBRSxFQUFFLEdBQUcsU0FBUyxFQUNwQixTQUFTLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDN0IsS0FBSyxFQUFFLE1BQU0sR0FBRyxTQUFTLEVBQ3pCLFFBQVEsRUFBRSxZQUFZLEdBQUcsU0FBUyxFQUNsQyxZQUFZLEVBQUUsT0FBTyxFQUNyQixrQkFBa0IsRUFBRSxPQUFPLEVBQzNCLFlBQVksRUFBRSxPQUFPLEVBQ3JCLGFBQWEsRUFBRSxPQUFPLEVBQ3RCLElBQUksRUFBRSxPQUFPLEVBQ2IsT0FBTyxFQUFFLFVBQVUsRUFDbkIsYUFBYSxFQUFFLFFBQVEsRUFDdkIsSUFBSSxFQUFFLE9BQU8sRUFDYixPQUFPLEVBQUUsT0FBTyxFQUNoQixXQUFXLEVBQUUsTUFBTSxFQUNuQixHQUFHLEVBQUUsS0FBSzs7Ozs7O0dBMElYIn0=

package/dest/cmds/create_account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_account.d.ts","sourceRoot":"","sources":["../../src/cmds/create_account.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,2BAA2B,CAAC;AAGtE,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAA+B,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAG9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEtD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,cAAc,GAAG,SAAS,EACtC,IAAI,EAAE,EAAE,GAAG,SAAS,EACpB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,EAAE,YAAY,GAAG,SAAS,EAClC,YAAY,EAAE,OAAO,EACrB,kBAAkB,EAAE,OAAO,EAC3B,YAAY,EAAE,OAAO,EACrB,aAAa,EAAE,OAAO,EACtB,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,QAAQ,EACvB,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,KAAK;;;;;;GA0IX"}

package/dest/cmds/create_account.js

@@ -0,0 +1,146 @@
+import { deriveSecretKeyFromSigningKey } from '@aztec-labs/accounts/utils';
+import { NO_FROM } from '@aztec-labs/aztec.js/account';
+import { NO_WAIT } from '@aztec-labs/aztec.js/contracts';
+import { waitForTx } from '@aztec-labs/aztec.js/node';
+import { prettyPrintJSON } from '@aztec-labs/cli/cli-utils';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+import { printProfileResult } from '../utils/profiling.js';
+export async function createAccount(wallet, aztecNode, accountType, signingKey, salt, publicKey, alias, deployer, registerOnly, skipInitialization, publicDeploy, registerClass, wait, feeOpts, waitForStatus, json, verbose, debugLogger, log) {
+    let secretKey;
+    if (accountType === 'ecdsasecp256r1ssh') {
+        // SSH accounts sign with a key held in the agent, and so we cannot derive their privacy secret key from it. Instead
+        // we pick a random value.
+        secretKey = Fr.random();
+    } else {
+        signingKey ??= GrumpkinScalar.random();
+        secretKey = await deriveSecretKeyFromSigningKey(signingKey);
+    }
+    const account = await wallet.createAccount(accountType, signingKey, secretKey, salt, publicKey);
+    const instanceSalt = account.getInstance().salt;
+    const { address, publicKeys, partialAddress } = await account.getCompleteAddress();
+    const out = {};
+    if (json) {
+        out.address = address;
+        out.publicKey = publicKeys;
+        if (signingKey) {
+            out.signingKey = signingKey;
+        }
+        if (secretKey) {
+            out.secretKey = secretKey;
+        }
+        out.partialAddress = partialAddress;
+        out.salt = instanceSalt;
+        out.initHash = account.getInstance().initializationHash;
+    } else {
+        log(`\nNew account:\n`);
+        log(`Address:         ${address.toString()}`);
+        log(`Public key:      ${publicKeys.toString()}`);
+        if (signingKey) {
+            log(`Signing key:     ${signingKey.toString()}`);
+        }
+        if (secretKey) {
+            log(`Secret key:     ${secretKey.toString()}`);
+        }
+        log(`Partial address: ${partialAddress.toString()}`);
+        log(`Salt:            ${instanceSalt.toString()}`);
+        log(`Init hash:       ${account.getInstance().initializationHash.toString()}`);
+    }
+    let txHash;
+    let txReceipt;
+    // Initializerless accounts have no deployment tx — creating one only registers it locally — so there is
+    // nothing to deploy on-chain.
+    if (!registerOnly && accountType !== 'schnorr_initializerless') {
+        const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(aztecNode, wallet, address);
+        const delegatedDeployment = deployer && !account.address.equals(deployer);
+        const from = delegatedDeployment ? deployer : NO_FROM;
+        const deployAccountOpts = {
+            skipClassPublication: !registerClass,
+            skipInstancePublication: !publicDeploy,
+            skipInitialization,
+            from,
+            fee: {
+                paymentMethod,
+                gasSettings
+            }
+        };
+        const localStart = performance.now();
+        const deployMethod = await account.getDeployMethod();
+        const sim = await deployMethod.simulate({
+            ...deployAccountOpts,
+            includeMetadata: true
+        });
+        // includeMetadata: true guarantees these fields are present
+        const estimatedGas = await wallet.estimateGasLimits(sim.gasUsed);
+        const stats = sim.stats;
+        if (feeOpts.estimateOnly) {
+            if (json) {
+                out.fee = {
+                    gasLimits: {
+                        da: estimatedGas.gasLimits.daGas,
+                        l2: estimatedGas.gasLimits.l2Gas
+                    },
+                    teardownGasLimits: {
+                        da: estimatedGas.teardownGasLimits.daGas,
+                        l2: estimatedGas.teardownGasLimits
+                    }
+                };
+            }
+        } else {
+            if (verbose) {
+                printProfileResult(stats, log);
+            }
+            if (!json) {
+                log(`\nWaiting for account contract deployment...`);
+            }
+            const sendOpts = {
+                ...deployAccountOpts,
+                fee: deployAccountOpts.fee ? {
+                    ...deployAccountOpts.fee,
+                    gasSettings: estimatedGas
+                } : undefined
+            };
+            ({ txHash } = await deployMethod.send({
+                ...sendOpts,
+                wait: NO_WAIT
+            }));
+            const localTimeMs = performance.now() - localStart;
+            if (wait) {
+                const nodeStart = performance.now();
+                txReceipt = await waitForTx(aztecNode, txHash, {
+                    timeout: DEFAULT_TX_TIMEOUT_S,
+                    waitForStatus
+                });
+                const nodeTimeMs = performance.now() - nodeStart;
+                out.txReceipt = {
+                    status: txReceipt.status,
+                    transactionFee: txReceipt.transactionFee
+                };
+                if (!json) {
+                    log(` Local processing time: ${(localTimeMs / 1000).toFixed(1)}s`);
+                    log(` Node inclusion time: ${(nodeTimeMs / 1000).toFixed(1)}s`);
+                }
+            }
+            debugLogger.debug(`Account contract tx sent with hash ${txHash.toString()}`);
+            out.txHash = txHash;
+        }
+    }
+    if (json) {
+        log(prettyPrintJSON(out));
+    } else {
+        if (txHash) {
+            log(`Deploy tx hash:  ${txHash.toString()}`);
+        }
+        if (txReceipt) {
+            log(`Deploy tx fee:   ${txReceipt.transactionFee}`);
+        }
+    }
+    return {
+        alias,
+        address,
+        signingKey,
+        secretKey,
+        salt: instanceSalt
+    };
+}

package/dest/cmds/create_authwit.d.ts

@@ -0,0 +1,5 @@
+import type { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { CLIWallet } from '../utils/wallet.js';
+export declare function createAuthwit(wallet: CLIWallet, from: AztecAddress, functionName: string, caller: AztecAddress, functionArgsIn: any[], contractArtifactPath: string, contractAddress: AztecAddress, log: LogFn): Promise<import("@aztec-labs/stdlib/auth-witness").AuthWitness>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlX2F1dGh3aXQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbWRzL2NyZWF0ZV9hdXRod2l0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBR25FLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRXhELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELHdCQUFzQixhQUFhLENBQ2pDLE1BQU0sRUFBRSxTQUFTLEVBQ2pCLElBQUksRUFBRSxZQUFZLEVBQ2xCLFlBQVksRUFBRSxNQUFNLEVBQ3BCLE1BQU0sRUFBRSxZQUFZLEVBQ3BCLGNBQWMsRUFBRSxHQUFHLEVBQUUsRUFDckIsb0JBQW9CLEVBQUUsTUFBTSxFQUM1QixlQUFlLEVBQUUsWUFBWSxFQUM3QixHQUFHLEVBQUUsS0FBSyxrRUF1QlgifQ==

package/dest/cmds/create_authwit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_authwit.d.ts","sourceRoot":"","sources":["../../src/cmds/create_authwit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAGnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,YAAY,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,YAAY,EACpB,cAAc,EAAE,GAAG,EAAE,EACrB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,YAAY,EAC7B,GAAG,EAAE,KAAK,kEAuBX"}

package/dest/cmds/create_authwit.js

@@ -0,0 +1,16 @@
+import { Contract } from '@aztec-labs/aztec.js/contracts';
+import { prepTx } from '@aztec-labs/cli/utils';
+export async function createAuthwit(wallet, from, functionName, caller, functionArgsIn, contractArtifactPath, contractAddress, log) {
+    const { functionArgs, contractArtifact, isPrivate } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+    if (!isPrivate) {
+        throw new Error('Cannot create an authwit for a public function. To allow a third party to call a public function, please authorize the action via the authorize-action command');
+    }
+    const contract = Contract.at(contractAddress, contractArtifact, wallet);
+    const call = await contract.methods[functionName](...functionArgs).getFunctionCall();
+    const witness = await wallet.createAuthWit(from, {
+        caller,
+        call
+    });
+    log(`Created authorization witness for action ${functionName} on contract ${contractAddress} for caller ${caller}`);
+    return witness;
+}

package/dest/cmds/deploy.d.ts

@@ -0,0 +1,10 @@
+import type { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import { type AztecNode } from '@aztec-labs/aztec.js/node';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import { PublicKeys } from '@aztec-labs/stdlib/keys';
+import type { TxStatus } from '@aztec-labs/stdlib/tx';
+import { CLIFeeArgs } from '../utils/options/fees.js';
+import type { CLIWallet } from '../utils/wallet.js';
+export declare function deploy(wallet: CLIWallet, node: AztecNode, deployer: AztecAddress, artifactPath: string, json: boolean, publicKeys: PublicKeys | undefined, rawArgs: any[], salt: Fr | undefined, initializer: string | undefined, skipInstancePublication: boolean, skipClassPublication: boolean, skipInitialization: boolean | undefined, wait: boolean, feeOpts: CLIFeeArgs, waitForStatus: TxStatus, verbose: boolean, timeout: number | undefined, debugLogger: Logger, log: LogFn, universal?: boolean): Promise<AztecAddress>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY21kcy9kZXBsb3kudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFJbkUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2pELE9BQU8sRUFBRSxLQUFLLFNBQVMsRUFBYSxNQUFNLDJCQUEyQixDQUFDO0FBRXRFLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUVoRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHdEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXRELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELHdCQUFzQixNQUFNLENBQzFCLE1BQU0sRUFBRSxTQUFTLEVBQ2pCLElBQUksRUFBRSxTQUFTLEVBQ2YsUUFBUSxFQUFFLFlBQVksRUFDdEIsWUFBWSxFQUFFLE1BQU0sRUFDcEIsSUFBSSxFQUFFLE9BQU8sRUFDYixVQUFVLEVBQUUsVUFBVSxHQUFHLFNBQVMsRUFDbEMsT0FBTyxFQUFFLEdBQUcsRUFBRSxFQUNkLElBQUksRUFBRSxFQUFFLEdBQUcsU0FBUyxFQUNwQixXQUFXLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDL0IsdUJBQXVCLEVBQUUsT0FBTyxFQUNoQyxvQkFBb0IsRUFBRSxPQUFPLEVBQzdCLGtCQUFrQixFQUFFLE9BQU8sR0FBRyxTQUFTLEVBQ3ZDLElBQUksRUFBRSxPQUFPLEVBQ2IsT0FBTyxFQUFFLFVBQVUsRUFDbkIsYUFBYSxFQUFFLFFBQVEsRUFDdkIsT0FBTyxFQUFFLE9BQU8sRUFDaEIsT0FBTyxvQkFBK0IsRUFDdEMsV0FBVyxFQUFFLE1BQU0sRUFDbkIsR0FBRyxFQUFFLEtBQUssRUFDVixTQUFTLENBQUMsRUFBRSxPQUFPLHlCQXNIcEIifQ==