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

package/dest/utils/constants.js

@@ -0,0 +1,8 @@
+export const MIN_FEE_PADDING = 0.5;
+export const AccountTypes = [
+    'schnorr',
+    'schnorr_initializerless',
+    'ecdsasecp256r1',
+    'ecdsasecp256r1ssh',
+    'ecdsasecp256k1'
+];

package/dest/utils/ecdsa.d.ts

@@ -0,0 +1,2 @@
+export declare function extractECDSAPublicKeyFromBase64String(base64PublicKey: string): Buffer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWNkc2EuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9lY2RzYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3QkFBZ0IscUNBQXFDLENBQUMsZUFBZSxFQUFFLE1BQU0sR0FBRyxNQUFNLENBY3JGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../src/utils/ecdsa.ts"],"names":[],"mappings":"AAAA,wBAAgB,qCAAqC,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAcrF"}

package/dest/utils/ecdsa.js

@@ -0,0 +1,13 @@
+export function extractECDSAPublicKeyFromBase64String(base64PublicKey) {
+    const buffer = Buffer.from(base64PublicKey, 'base64');
+    let keyOffset = 0;
+    const typeLen = buffer.readUInt32BE(keyOffset);
+    keyOffset += 4;
+    keyOffset += typeLen;
+    const curveLen = buffer.readUInt32BE(keyOffset);
+    keyOffset += 4;
+    keyOffset += curveLen;
+    const keyLen = buffer.readUInt32BE(keyOffset);
+    keyOffset += 5; // 4+1 to remove the prefix
+    return buffer.subarray(keyOffset, keyOffset + keyLen - 1);
+}

package/dest/utils/options/fees.d.ts

@@ -0,0 +1,36 @@
+import type { FeePaymentMethod } from '@aztec-labs/aztec.js/fee';
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import type { Wallet } from '@aztec-labs/aztec.js/wallet';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { GasFees, GasSettings } from '@aztec-labs/stdlib/gas';
+import type { FeeOptions } from '@aztec-labs/wallet-sdk/base-wallet';
+import { Option } from 'commander';
+import type { WalletDB } from '../../storage/wallet_db.js';
+export type RawCliFeeArgs = {
+    estimateGasOnly: boolean;
+    gasLimits?: string;
+    payment?: string;
+    maxFeesPerGas?: string;
+    maxPriorityFeesPerGas?: string;
+};
+export type ParsedFeeOptions = {
+    paymentMethod?: FeePaymentMethod;
+    gasSettings?: Partial<FieldsOf<GasSettings>>;
+};
+export declare function getPaymentMethodOption(): Option;
+export declare function parsePaymentMethod(payment: string, log: LogFn, db?: WalletDB, estimateOnly?: boolean): (wallet: Wallet, from: AztecAddress, gasSettings: GasSettings) => Promise<FeePaymentMethod | undefined>;
+export declare function parseGasFees(gasFees: string): GasFees;
+export declare class CLIFeeArgs {
+    estimateOnly: boolean;
+    private paymentMethod;
+    private gasSettings;
+    constructor(estimateOnly: boolean, paymentMethod: (wallet: Wallet, feePayer: AztecAddress, gasSettings: GasSettings) => Promise<FeePaymentMethod | undefined>, gasSettings: Partial<FieldsOf<GasSettings>>);
+    toUserFeeOptions(node: AztecNode, wallet: Wallet, from: AztecAddress): Promise<ParsedFeeOptions>;
+    private getMinFees;
+    static parse(args: RawCliFeeArgs, log: LogFn, db?: WalletDB): CLIFeeArgs;
+    static getOptions(): Option[];
+}
+export declare function printGasEstimates(feeOpts: FeeOptions, gasEstimates: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>, log: LogFn): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL29wdGlvbnMvZmVlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRTFELE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQzdELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNoRSxPQUFPLEVBQU8sT0FBTyxFQUFFLFdBQVcsRUFBcUIsTUFBTSx3QkFBd0IsQ0FBQztBQUN0RixPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNyRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBRW5DLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBSTNELE1BQU0sTUFBTSxhQUFhLEdBQUc7SUFDMUIsZUFBZSxFQUFFLE9BQU8sQ0FBQztJQUN6QixTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbkIsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLGFBQWEsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN2QixxQkFBcUIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNoQyxDQUFDO0FBRUYsTUFBTSxNQUFNLGdCQUFnQixHQUFHO0lBQzdCLGFBQWEsQ0FBQyxFQUFFLGdCQUFnQixDQUFDO0lBQ2pDLFdBQVcsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztDQUM5QyxDQUFDO0FBeURGLHdCQUFnQixzQkFBc0IsV0FHckM7QUEwQkQsd0JBQWdCLGtCQUFrQixDQUNoQyxPQUFPLEVBQUUsTUFBTSxFQUNmLEdBQUcsRUFBRSxLQUFLLEVBQ1YsRUFBRSxDQUFDLEVBQUUsUUFBUSxFQUNiLFlBQVksQ0FBQyxFQUFFLE9BQU8sR0FDckIsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLFdBQVcsS0FBSyxPQUFPLENBQUMsZ0JBQWdCLEdBQUcsU0FBUyxDQUFDLENBcUZ6RztBQXlCRCx3QkFBZ0IsWUFBWSxDQUFDLE9BQU8sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQWtCckQ7QUFDRCxxQkFBYSxVQUFVO0lBRVosWUFBWSxFQUFFLE9BQU87SUFDNUIsT0FBTyxDQUFDLGFBQWE7SUFLckIsT0FBTyxDQUFDLFdBQVc7SUFQckIsWUFDUyxZQUFZLEVBQUUsT0FBTyxFQUNwQixhQUFhLEVBQUUsQ0FDckIsTUFBTSxFQUFFLE1BQU0sRUFDZCxRQUFRLEVBQUUsWUFBWSxFQUN0QixXQUFXLEVBQUUsV0FBVyxLQUNyQixPQUFPLENBQUMsZ0JBQWdCLEdBQUcsU0FBUyxDQUFDLEVBQ2xDLFdBQVcsRUFBRSxPQUFPLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxDQUFDLEVBQ2pEO0lBRUUsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBV3JHO1lBTWEsVUFBVTtJQWlCeEIsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsYUFBYSxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDLEVBQUUsUUFBUSxHQUFHLFVBQVUsQ0FPdkU7SUFFRCxNQUFNLENBQUMsVUFBVSxhQUVoQjtDQUNGO0FBSUQsd0JBQWdCLGlCQUFpQixDQUMvQixPQUFPLEVBQUUsVUFBVSxFQUNuQixZQUFZLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsbUJBQW1CLENBQUMsRUFDbEUsR0FBRyxFQUFFLEtBQUssUUFJWCJ9

package/dest/utils/options/fees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fees.d.ts","sourceRoot":"","sources":["../../../src/utils/options/fees.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAO,OAAO,EAAE,WAAW,EAAqB,MAAM,wBAAwB,CAAC;AACtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAI3D,MAAM,MAAM,aAAa,GAAG;IAC1B,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,aAAa,CAAC,EAAE,gBAAgB,CAAC;IACjC,WAAW,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;CAC9C,CAAC;AAyDF,wBAAgB,sBAAsB,WAGrC;AA0BD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,KAAK,EACV,EAAE,CAAC,EAAE,QAAQ,EACb,YAAY,CAAC,EAAE,OAAO,GACrB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAqFzG;AAyBD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAkBrD;AACD,qBAAa,UAAU;IAEZ,YAAY,EAAE,OAAO;IAC5B,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,WAAW;IAPrB,YACS,YAAY,EAAE,OAAO,EACpB,aAAa,EAAE,CACrB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,YAAY,EACtB,WAAW,EAAE,WAAW,KACrB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,EAClC,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,EACjD;IAEE,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAWrG;YAMa,UAAU;IAiBxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,UAAU,CAOvE;IAED,MAAM,CAAC,UAAU,aAEhB;CACF;AAID,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,UAAU,EACnB,YAAY,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,mBAAmB,CAAC,EAClE,GAAG,EAAE,KAAK,QAIX"}

package/dest/utils/options/fees.js

@@ -0,0 +1,250 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { Gas, GasFees, GasSettings, ManaUsageEstimate } from '@aztec-labs/stdlib/gas';
+import { Option } from 'commander';
+import { MIN_FEE_PADDING } from '../constants.js';
+import { aliasedAddressParser } from './options.js';
+function printOptionParams(params) {
+    const paramsWithDescription = Object.keys(params).filter((name)=>params[name].description);
+    const maxParamWidth = paramsWithDescription.reduce((v, name)=>Math.max(v, name.length), 0);
+    const indent = (size)=>''.padEnd(size, ' ');
+    const descriptionList = paramsWithDescription.map((name)=>[
+            `${indent(5)}${name}${indent(maxParamWidth - name.length)}  ${params[name].description}`,
+            params[name].default ? `Default: ${params[name].default}` : ''
+        ].join(' '));
+    return descriptionList.length ? `\n   Parameters:\n${descriptionList.join('\n')}\nFormat: --payment ${Object.keys(params).slice(0, 3).map((name)=>`${name}=${params[name].type}`)} ${Object.keys(params).length > 3 ? '...' : ''}` : '';
+}
+function getFeePaymentMethodParams() {
+    return {
+        method: {
+            type: 'name',
+            description: 'Valid values: "fee_juice", "fpc-public", "fpc-private", "fpc-sponsored"',
+            default: 'fee_juice'
+        },
+        asset: {
+            type: 'address',
+            description: 'The asset used for fee payment. Required for "fpc-public" and "fpc-private".'
+        },
+        fpc: {
+            type: 'address',
+            description: 'The FPC contract that pays in fee juice. Not required for the "fee_juice" method.'
+        },
+        claim: {
+            type: 'boolean',
+            description: 'Whether to use a previously stored claim to bridge fee juice.'
+        },
+        claimSecret: {
+            type: 'string',
+            description: 'The secret to claim fee juice on L1.'
+        },
+        claimAmount: {
+            type: 'bigint',
+            description: 'The amount of fee juice to be claimed.'
+        },
+        messageLeafIndex: {
+            type: 'bigint',
+            description: 'The index of the claim in the l1toL2Message tree.'
+        }
+    };
+}
+export function getPaymentMethodOption() {
+    const params = getFeePaymentMethodParams();
+    return new Option(`--payment <options>`, `Fee payment method and arguments.${printOptionParams(params)}`);
+}
+function getFeeOptions() {
+    return [
+        getPaymentMethodOption(),
+        new Option('--gas-limits <da=100,l2=100,teardownDA=10,teardownL2=10>', 'Gas limits for the tx.'),
+        new Option('--max-fees-per-gas <da=100,l2=100>', 'Maximum fees per gas unit for DA and L2 computation.'),
+        new Option('--max-priority-fees-per-gas <da=0,l2=0>', 'Maximum priority fees per gas unit for DA and L2 computation.'),
+        new Option('--estimate-gas-only', 'Only report gas estimation for the tx, do not send it.')
+    ];
+}
+function parseGasSettings(args) {
+    const gasLimits = args.gasLimits ? parseGasLimits(args.gasLimits) : {};
+    const maxFeesPerGas = args.maxFeesPerGas ? parseGasFees(args.maxFeesPerGas) : undefined;
+    const maxPriorityFeesPerGas = args.maxPriorityFeesPerGas ? parseGasFees(args.maxPriorityFeesPerGas) : undefined;
+    return {
+        ...gasLimits,
+        maxFeesPerGas,
+        maxPriorityFeesPerGas
+    };
+}
+export function parsePaymentMethod(payment, log, db, estimateOnly) {
+    const parsed = payment.split(',').reduce((acc, item)=>{
+        const [dimension, value] = item.split('=');
+        acc[dimension] = value ?? 1;
+        return acc;
+    }, {});
+    const getFpc = ()=>{
+        if (!parsed.fpc) {
+            throw new Error('Missing "fpc" in payment option');
+        }
+        return aliasedAddressParser('contracts', parsed.fpc, db);
+    };
+    const getAsset = ()=>{
+        if (!parsed.asset) {
+            throw new Error('Missing "asset" in payment option');
+        }
+        return AztecAddress.fromStringUnsafe(parsed.asset);
+    };
+    return async (wallet, from, gasSettings)=>{
+        switch(parsed.method){
+            case 'fee_juice':
+                {
+                    if (parsed.claim || parsed.claimSecret && parsed.claimAmount && parsed.messageLeafIndex) {
+                        let claimAmount, claimSecret, messageLeafIndex;
+                        if (parsed.claim && db) {
+                            ({ amount: claimAmount, secret: claimSecret, leafIndex: messageLeafIndex } = estimateOnly ? await db.peekBridgedFeeJuice(from, log) : await db.popBridgedFeeJuice(from, log));
+                        } else {
+                            ({ claimAmount, claimSecret, messageLeafIndex } = parsed);
+                        }
+                        log(`Using Fee Juice for fee payments with claim for ${claimAmount} tokens`);
+                        const { FeeJuicePaymentMethodWithClaim } = await import('@aztec-labs/aztec.js/fee');
+                        return new FeeJuicePaymentMethodWithClaim(from, {
+                            claimAmount: (typeof claimAmount === 'string' ? Fr.fromString(claimAmount) : new Fr(claimAmount)).toBigInt(),
+                            claimSecret: typeof claimSecret === 'string' ? Fr.fromString(claimSecret) : claimSecret,
+                            messageLeafIndex: BigInt(messageLeafIndex)
+                        });
+                    } else {
+                        log(`Using Fee Juice for fee payment with the balance of account ${from}`);
+                        return;
+                    }
+                }
+            case 'fpc-public':
+                {
+                    const fpc = getFpc();
+                    const asset = getAsset();
+                    log(`WARNING: fpc-public is deprecated and will not work on mainnet alpha. Use fee_juice or fpc-sponsored instead.`);
+                    log(`Using public fee payment with asset ${asset} via paymaster ${fpc}`);
+                    const { PublicFeePaymentMethod } = await import('@aztec-labs/aztec.js/fee');
+                    return new PublicFeePaymentMethod(fpc, from, wallet, gasSettings);
+                }
+            case 'fpc-private':
+                {
+                    const fpc = getFpc();
+                    const asset = getAsset();
+                    log(`WARNING: fpc-private is deprecated and will not work on mainnet alpha. Use fee_juice or fpc-sponsored instead.`);
+                    log(`Using private fee payment with asset ${asset} via paymaster ${fpc}`);
+                    const { PrivateFeePaymentMethod } = await import('@aztec-labs/aztec.js/fee');
+                    return new PrivateFeePaymentMethod(fpc, from, wallet, gasSettings);
+                }
+            case 'fpc-sponsored':
+                {
+                    const sponsor = getFpc();
+                    log(`Using sponsored fee payment with sponsor ${sponsor}`);
+                    const { SponsoredFeePaymentMethod } = await import('@aztec-labs/aztec.js/fee/testing');
+                    return new SponsoredFeePaymentMethod(sponsor);
+                }
+            case undefined:
+                throw new Error('Missing "method" in payment option');
+            default:
+                throw new Error(`Invalid fee payment method: ${payment}`);
+        }
+    };
+}
+function parseGasLimits(gasLimits) {
+    const parsed = gasLimits.split(',').reduce((acc, limit)=>{
+        const [dimension, value] = limit.split('=');
+        acc[dimension] = parseInt(value, 10);
+        return acc;
+    }, {});
+    const expected = [
+        'da',
+        'l2',
+        'teardownDA',
+        'teardownL2'
+    ];
+    for (const dimension of expected){
+        if (!(dimension in parsed)) {
+            throw new Error(`Missing gas limit for ${dimension}`);
+        }
+    }
+    return {
+        gasLimits: new Gas(parsed.da, parsed.l2),
+        teardownGasLimits: new Gas(parsed.teardownDA, parsed.teardownL2)
+    };
+}
+export function parseGasFees(gasFees) {
+    const parsed = gasFees.split(',').reduce((acc, fee)=>{
+        const [dimension, value] = fee.split('=');
+        acc[dimension] = parseInt(value, 10);
+        return acc;
+    }, {});
+    const expected = [
+        'da',
+        'l2'
+    ];
+    for (const dimension of expected){
+        if (!(dimension in parsed)) {
+            throw new Error(`Missing gas fee for ${dimension}`);
+        }
+    }
+    return new GasFees(parsed.da, parsed.l2);
+}
+export class CLIFeeArgs {
+    estimateOnly;
+    paymentMethod;
+    gasSettings;
+    constructor(estimateOnly, paymentMethod, gasSettings){
+        this.estimateOnly = estimateOnly;
+        this.paymentMethod = paymentMethod;
+        this.gasSettings = gasSettings;
+    }
+    async toUserFeeOptions(node, wallet, from) {
+        const minFees = await this.getMinFees(node);
+        const maxFeesPerGas = minFees.mul(1 + MIN_FEE_PADDING);
+        const { txsLimits } = await node.getNodeInfo();
+        const gasLimits = this.gasSettings.gasLimits ?? Gas.from(txsLimits.gas);
+        const gasSettings = GasSettings.fallback({
+            ...this.gasSettings,
+            gasLimits,
+            maxFeesPerGas
+        });
+        const paymentMethod = await this.paymentMethod(wallet, from, gasSettings);
+        return {
+            paymentMethod,
+            gasSettings
+        };
+    }
+    /**
+   * Returns the worst-case min fee across predicted future slots.
+   * Falls back to getCurrentMinFees if the node doesn't support getPredictedMinFees.
+   */ async getMinFees(node) {
+        try {
+            const predicted = await node.getPredictedMinFees(ManaUsageEstimate.Limit);
+            if (predicted.length === 0) {
+                return node.getCurrentMinFees();
+            }
+            return predicted.reduce((worst, fees)=>fees.feePerL2Gas > worst.feePerL2Gas ? fees : worst);
+        } catch (err) {
+            // Fallback for old nodes that don't support getPredictedMinFees.
+            // Only fall back on method-not-found errors (JSON-RPC code -32601); rethrow others.
+            if (err?.cause?.code === -32601 || err?.message?.includes('Method not found')) {
+                return node.getCurrentMinFees();
+            }
+            throw err;
+        }
+    }
+    static parse(args, log, db) {
+        const estimateOnly = !!args.estimateGasOnly;
+        return new CLIFeeArgs(estimateOnly, parsePaymentMethod(args.payment ?? 'method=fee_juice', log, db, estimateOnly), parseGasSettings(args));
+    }
+    static getOptions() {
+        return getFeeOptions();
+    }
+}
+// Printing
+export function printGasEstimates(feeOpts, gasEstimates, log) {
+    log(`Estimated gas usage:    ${formatGasEstimate(gasEstimates)}`);
+    log(`Maximum total tx fee:   ${getEstimatedCost(gasEstimates, feeOpts.gasSettings.maxFeesPerGas)}`);
+}
+function formatGasEstimate(estimate) {
+    return `da=${estimate.gasLimits.daGas},l2=${estimate.gasLimits.l2Gas},teardownDA=${estimate.teardownGasLimits.daGas},teardownL2=${estimate.teardownGasLimits.l2Gas}`;
+}
+function getEstimatedCost(estimate, maxFeesPerGas) {
+    return GasSettings.fallback({
+        ...estimate,
+        maxFeesPerGas
+    }).getFeeLimit().toBigInt();
+}

package/dest/utils/options/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fees.js';
+export * from './options.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9vcHRpb25zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsY0FBYyxDQUFDIn0=

package/dest/utils/options/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/options/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/dest/utils/options/index.js

@@ -0,0 +1,2 @@
+export * from './fees.js';
+export * from './options.js';

package/dest/utils/options/options.d.ts

@@ -0,0 +1,24 @@
+import { TxHash } from '@aztec-labs/aztec.js/tx';
+import { AuthWitness } from '@aztec-labs/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { Option } from 'commander';
+import type { AliasType, WalletDB } from '../../storage/wallet_db.js';
+export declare const ARTIFACT_DESCRIPTION = "Path to a compiled Aztec contract's artifact in JSON format. If executed inside a nargo workspace, a package and contract name can be specified as package@contract";
+export declare function integerArgParser(value: string, argName: string, min?: number, max?: number): number;
+export declare function aliasedTxHashParser(txHash: string, db?: WalletDB): TxHash;
+export declare function aliasedAuthWitParser(witnesses: string, db?: WalletDB): AuthWitness[];
+export declare function aliasedAddressParser(defaultPrefix: AliasType, address: string, db?: WalletDB): AztecAddress;
+export declare function aliasedSigningKeyParser(sk: string, db?: WalletDB): import("@aztec-labs/foundation/schemas").Fq;
+export declare function createAliasOption(description: string, hide: boolean): Option;
+export declare function createAccountOption(description: string, hide: boolean, db?: WalletDB): Option;
+export declare function createAuthwitnessOption(description: string, hide: boolean, db?: WalletDB): Option;
+export declare function createTypeOption(mandatory: boolean): Option;
+export declare function createArgsOption(isConstructor: boolean, db?: WalletDB): Option;
+export declare function createContractAddressOption(db?: WalletDB): Option;
+export declare function createDebugExecutionStepsDirOption(): Option;
+export declare function createVerboseOption(): Option;
+export declare function artifactPathParser(filePath: string, db?: WalletDB): Promise<string>;
+export declare function artifactPathFromPromiseOrAlias(artifactPathPromise: Promise<string>, contractAddress: AztecAddress, db?: WalletDB): Promise<string>;
+export declare function createArtifactOption(db?: WalletDB): Option;
+export declare function cleanupAuthWitnesses(authWitnesses: AuthWitness[] | undefined): AuthWitness[];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/utils/options/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAKtE,eAAO,MAAM,oBAAoB,wKACsI,CAAC;AAExK,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,GAAG,SAA0B,EAC7B,GAAG,SAA0B,UAU9B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAQzE;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,iBAYpE;AAED,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,gBAQ5F;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,+CAQhE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,UAEnE;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,QAAQ,UAIpF;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,QAAQ,UAIxF;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,UAMlD;AAED,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,QAAQ,UAQrE;AAED,wBAAgB,2BAA2B,CAAC,EAAE,CAAC,EAAE,QAAQ,UAIxD;AAED,wBAAgB,kCAAkC,WAKjD;AAED,wBAAgB,mBAAmB,WAKlC;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,mBAajE;AAED,wBAAsB,8BAA8B,CAClD,mBAAmB,EAAE,OAAO,CAAC,MAAM,CAAC,EACpC,eAAe,EAAE,YAAY,EAC7B,EAAE,CAAC,EAAE,QAAQ,mBAWd;AAED,wBAAgB,oBAAoB,CAAC,EAAE,CAAC,EAAE,QAAQ,UAIjD;AA6BD,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,WAAW,EAAE,GAAG,SAAS,GAAG,WAAW,EAAE,CAE5F"}

package/dest/utils/options/options.js

@@ -0,0 +1,134 @@
+import { parseAztecAddress, parseSigningKey, parseTxHash } from '@aztec-labs/cli/utils';
+import { AuthWitness } from '@aztec-labs/stdlib/auth-witness';
+import { Option } from 'commander';
+import { readdir, stat } from 'fs/promises';
+import { AccountTypes } from '../constants.js';
+const TARGET_DIR = 'target';
+export const ARTIFACT_DESCRIPTION = "Path to a compiled Aztec contract's artifact in JSON format. If executed inside a nargo workspace, a package and contract name can be specified as package@contract";
+export function integerArgParser(value, argName, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+    const parsed = parseInt(value, 10);
+    if (parsed < min) {
+        throw new Error(`${argName} must be greater than ${min}`);
+    }
+    if (parsed > max) {
+        throw new Error(`${argName} must be less than ${max}`);
+    }
+    return parsed;
+}
+export function aliasedTxHashParser(txHash, db) {
+    try {
+        return parseTxHash(txHash);
+    } catch  {
+        const prefixed = txHash.includes(':') ? txHash : `transactions:${txHash}`;
+        const rawTxHash = db ? db.tryRetrieveAlias(prefixed) : txHash;
+        return parseTxHash(rawTxHash);
+    }
+}
+export function aliasedAuthWitParser(witnesses, db) {
+    const parsedWitnesses = witnesses.split(',').map((witness)=>{
+        try {
+            return AuthWitness.fromString(witness);
+        } catch  {
+            const prefixed = witness.includes(':') ? witness : `authwits:${witness}`;
+            const rawAuthWitness = db ? db.tryRetrieveAlias(prefixed) : witness;
+            return AuthWitness.fromString(rawAuthWitness);
+        }
+    });
+    return parsedWitnesses;
+}
+export function aliasedAddressParser(defaultPrefix, address, db) {
+    if (address.startsWith('0x')) {
+        return parseAztecAddress(address);
+    } else {
+        const prefixed = address.includes(':') ? address : `${defaultPrefix}:${address}`;
+        const rawAddress = db ? db.tryRetrieveAlias(prefixed) : address;
+        return parseAztecAddress(rawAddress);
+    }
+}
+export function aliasedSigningKeyParser(sk, db) {
+    if (sk.startsWith('0x')) {
+        return parseSigningKey(sk);
+    } else {
+        const prefixed = `${sk.startsWith('accounts') ? '' : 'accounts'}:${sk.endsWith(':signing') ? sk : `${sk}:signing`}`;
+        const rawSk = db ? db.tryRetrieveAlias(prefixed) : sk;
+        return parseSigningKey(rawSk);
+    }
+}
+export function createAliasOption(description, hide) {
+    return new Option(`-a, --alias <string>`, description).hideHelp(hide);
+}
+export function createAccountOption(description, hide, db) {
+    return new Option(`-f, --from <string>`, description).hideHelp(hide).argParser((address)=>aliasedAddressParser('accounts', address, db));
+}
+export function createAuthwitnessOption(description, hide, db) {
+    return new Option('-aw, --auth-witness <string,...>', description).hideHelp(hide).argParser((witness)=>aliasedAuthWitParser(witness, db));
+}
+export function createTypeOption(mandatory) {
+    return new Option('-t, --type <string>', 'Type of account to create').choices(AccountTypes).default('schnorr').conflicts('account-or-address').makeOptionMandatory(mandatory);
+}
+export function createArgsOption(isConstructor, db) {
+    return new Option('--args [args...]', `${isConstructor ? 'Constructor' : 'Function'}  arguments`).argParser((arg, prev)=>{
+        const next = db?.tryRetrieveAlias(arg) || arg;
+        prev.push(next);
+        return prev;
+    }).default([]);
+}
+export function createContractAddressOption(db) {
+    return new Option('-ca, --contract-address <address>', 'Aztec address of the contract.').argParser((address)=>aliasedAddressParser('contracts', address, db)).makeOptionMandatory(true);
+}
+export function createDebugExecutionStepsDirOption() {
+    return new Option('--debug-execution-steps-dir <address>', 'Directory to write execution step artifacts for bb profiling/debugging.').makeOptionMandatory(false);
+}
+export function createVerboseOption() {
+    return new Option('-v, --verbose', 'Provide timings on all executed operations (synching, simulating, proving)').default(false);
+}
+export function artifactPathParser(filePath, db) {
+    if (filePath.includes('@')) {
+        const [pkg, contractName] = filePath.split('@');
+        return contractArtifactFromWorkspace(pkg, contractName);
+    } else if (!new RegExp(/^(\.|\/|[A-Z]:).*\.json$/).test(filePath)) {
+        filePath = db ? db.tryRetrieveAlias(`artifacts:${filePath}`) : filePath;
+    }
+    if (!filePath) {
+        throw new Error('This command has to be called from a nargo workspace or contract artifact path should be provided');
+    }
+    return Promise.resolve(filePath);
+}
+export async function artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db) {
+    let artifactPath = await artifactPathPromise;
+    if (db && !artifactPath) {
+        artifactPath = db.tryRetrieveAlias(`artifacts:${contractAddress.toString()}`);
+        if (!artifactPath) {
+            throw new Error(`No artifact found for contract address ${contractAddress}, please provide it via the -c option`);
+        }
+    }
+    return artifactPath;
+}
+export function createArtifactOption(db) {
+    return new Option('-c, --contract-artifact <fileLocation>', ARTIFACT_DESCRIPTION).argParser((filePath)=>artifactPathParser(filePath, db)).makeOptionMandatory(false);
+}
+async function contractArtifactFromWorkspace(pkg, contractName) {
+    const cwd = process.cwd();
+    try {
+        await stat(`${cwd}/Nargo.toml`);
+    } catch  {
+        throw new Error('Invalid contract artifact argument provided. To use this option, command should be called from a nargo workspace');
+    }
+    const filesInTarget = await readdir(`${cwd}/${TARGET_DIR}`);
+    const bestMatch = filesInTarget.filter((file)=>{
+        if (pkg && contractName) {
+            return file === `${pkg}-${contractName}.json`;
+        } else {
+            return file.endsWith('.json') && (file.includes(pkg || '') || file.includes(contractName || ''));
+        }
+    });
+    if (bestMatch.length === 0) {
+        throw new Error('No contract artifacts found in target directory with the specified criteria');
+    } else if (bestMatch.length > 1) {
+        throw new Error(`Multiple contract artifacts found in target directory with the specified criteria ${bestMatch.join(', ')}`);
+    }
+    return `${cwd}/${TARGET_DIR}/${bestMatch[0]}`;
+}
+export function cleanupAuthWitnesses(authWitnesses) {
+    return authWitnesses?.filter((w)=>w !== undefined) ?? [];
+}

package/dest/utils/profiling.d.ts

@@ -0,0 +1,5 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import type { PrivateExecutionStep } from '@aztec-labs/stdlib/kernel';
+import type { ProvingStats, SimulationStats } from '@aztec-labs/stdlib/tx';
+export declare function printProfileResult(stats: ProvingStats | SimulationStats, log: LogFn, printOracles?: boolean, executionSteps?: PrivateExecutionStep[]): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZmlsaW5nLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvcHJvZmlsaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDdEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFrQixlQUFlLEVBQXFCLE1BQU0sdUJBQXVCLENBQUM7QUFTOUcsd0JBQWdCLGtCQUFrQixDQUNoQyxLQUFLLEVBQUUsWUFBWSxHQUFHLGVBQWUsRUFDckMsR0FBRyxFQUFFLEtBQUssRUFDVixZQUFZLEdBQUUsT0FBZSxFQUM3QixjQUFjLENBQUMsRUFBRSxvQkFBb0IsRUFBRSxRQTJKeEMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"profiling.d.ts","sourceRoot":"","sources":["../../src/utils/profiling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAkB,eAAe,EAAqB,MAAM,uBAAuB,CAAC;AAS9G,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,YAAY,GAAG,eAAe,EACrC,GAAG,EAAE,KAAK,EACV,YAAY,GAAE,OAAe,EAC7B,cAAc,CAAC,EAAE,oBAAoB,EAAE,QA2JxC"}

package/dest/utils/profiling.js

@@ -0,0 +1,68 @@
+import { format } from 'util';
+const FN_NAME_PADDING = 60;
+const COLUMN_MIN_WIDTH = 13;
+const COLUMN_MAX_WIDTH = 15;
+const ORACLE_NAME_PADDING = 50;
+export function printProfileResult(stats, log, printOracles = false, executionSteps) {
+    log(format('\nPer circuit breakdown:\n'));
+    log(format('  ', 'Function name'.padEnd(FN_NAME_PADDING), 'Time'.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), executionSteps ? 'Gates'.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH) : '', executionSteps ? 'Subtotal'.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH) : ''));
+    log(format(''.padEnd(FN_NAME_PADDING + COLUMN_MAX_WIDTH + COLUMN_MAX_WIDTH + (executionSteps ? COLUMN_MAX_WIDTH + COLUMN_MAX_WIDTH : 0), '-')));
+    let acc = 0;
+    let biggest = executionSteps?.[0];
+    const timings = stats.timings;
+    timings.perFunction.forEach((fn, i)=>{
+        const currentExecutionStep = executionSteps?.[i];
+        if (currentExecutionStep && biggest && currentExecutionStep.gateCount > biggest.gateCount) {
+            biggest = currentExecutionStep;
+        }
+        acc += currentExecutionStep ? currentExecutionStep.gateCount : 0;
+        log(format(' - ', fn.functionName.padEnd(FN_NAME_PADDING), `${fn.time.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), currentExecutionStep ? currentExecutionStep.gateCount.toLocaleString().padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH) : '', currentExecutionStep ? acc.toLocaleString().padStart(COLUMN_MAX_WIDTH) : ''));
+        if (printOracles && fn.oracles) {
+            log('');
+            for (const [oracleName, { times }] of Object.entries(fn.oracles)){
+                const calls = times.length;
+                const min = Math.min(...times);
+                const max = Math.max(...times);
+                const total = times.reduce((acc, time)=>acc + time, 0);
+                const avg = total / calls;
+                log(format('    ', oracleName.padEnd(ORACLE_NAME_PADDING), `${calls} calls`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), `${total.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), `min: ${min.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), `avg: ${avg.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), `max: ${max.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH)));
+            }
+        }
+        log('');
+    });
+    if (biggest) {
+        log(format('\nTotal gates:', acc.toLocaleString(), `(Biggest circuit: ${biggest.functionName} -> ${biggest.gateCount.toLocaleString()})`));
+    }
+    if (stats.nodeRPCCalls) {
+        log(format('\nRPC calls:\n'));
+        for (const [method, { times }] of Object.entries(stats.nodeRPCCalls.perMethod)){
+            const calls = times.length;
+            const total = times.reduce((acc, time)=>acc + time, 0);
+            const avg = total / calls;
+            const min = Math.min(...times);
+            const max = Math.max(...times);
+            log(format(method.padEnd(ORACLE_NAME_PADDING), `${calls} calls`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), `${total.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), `min: ${min.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), `avg: ${avg.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH), `max: ${max.toFixed(2)}ms`.padStart(COLUMN_MIN_WIDTH).padEnd(COLUMN_MAX_WIDTH)));
+        }
+        const { roundTrips } = stats.nodeRPCCalls;
+        log(format('\nRound trips (actual blocking waits):\n'));
+        log(format('Round trips:'.padEnd(25), `${roundTrips.roundTrips}`.padStart(COLUMN_MAX_WIDTH)));
+        log(format('Total blocking time:'.padEnd(25), `${roundTrips.totalBlockingTime.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH)));
+        if (roundTrips.roundTrips > 0) {
+            const avgRoundTrip = roundTrips.totalBlockingTime / roundTrips.roundTrips;
+            log(format('Avg round trip:'.padEnd(25), `${avgRoundTrip.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH)));
+        }
+    }
+    log(format('\nSync time:'.padEnd(25), `${timings.sync?.toFixed(2)}ms`.padStart(16)));
+    log(format('Private simulation time:'.padEnd(25), `${timings.perFunction.reduce((acc, { time })=>acc + time, 0).toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH)));
+    if (timings.proving) {
+        log(format('Proving time:'.padEnd(25), `${timings.proving?.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH)));
+    }
+    if (timings.publicSimulation) {
+        log(format('Public simulation time:'.padEnd(25), `${timings.publicSimulation?.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH)));
+    }
+    if (timings.validation) {
+        log(format('Validation time:'.padEnd(25), `${timings.validation?.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH)));
+    }
+    log(format('Total time:'.padEnd(25), `${timings.total.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH), `(${timings.unaccounted.toFixed(2)}ms unaccounted)`));
+    log('\n');
+}