@aztec/cli-wallet 0.0.0-test.0

package/dest/storage/wallet_db.js

@@ -0,0 +1,209 @@
+import { Fr } from '@aztec/foundation/fields';
+import { GasSettings } from '@aztec/stdlib/gas';
+import { extractECDSAPublicKeyFromBase64String } from '../utils/ecdsa.js';
+export const Aliases = [
+    'accounts',
+    'contracts',
+    'artifacts',
+    'secrets',
+    'transactions',
+    'authwits'
+];
+export class WalletDB {
+    #accounts;
+    #aliases;
+    #bridgedFeeJuice;
+    #transactions;
+    static instance;
+    aliasCache = new Map();
+    static getInstance() {
+        if (!WalletDB.instance) {
+            WalletDB.instance = new WalletDB();
+        }
+        return WalletDB.instance;
+    }
+    async init(store) {
+        this.#accounts = store.openMap('accounts');
+        this.#aliases = store.openMap('aliases');
+        this.#bridgedFeeJuice = store.openMap('bridgedFeeJuice');
+        this.#transactions = store.openMap('transactions');
+        await this.refreshAliasCache();
+    }
+    async refreshAliasCache() {
+        this.aliasCache = new Map((await this.listAliases()).map(({ key, value })=>[
+                key,
+                value
+            ]));
+    }
+    async pushBridgedFeeJuice(recipient, secret, amount, leafIndex, log) {
+        let stackPointer = (await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:stackPointer`))?.readInt8() || 0;
+        stackPointer++;
+        await this.#bridgedFeeJuice.set(`${recipient.toString()}:${stackPointer}`, Buffer.from(`${amount.toString()}:${secret.toString()}:${leafIndex.toString()}`));
+        await this.#bridgedFeeJuice.set(`${recipient.toString()}:stackPointer`, Buffer.from([
+            stackPointer
+        ]));
+        log(`Pushed ${amount} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+    }
+    async popBridgedFeeJuice(recipient, log) {
+        let stackPointer = (await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:stackPointer`))?.readInt8() || 0;
+        const result = await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:${stackPointer}`);
+        if (!result) {
+            throw new Error(`No stored fee juice available for recipient ${recipient.toString()}. Please provide claim amount and secret. Stack pointer ${stackPointer}`);
+        }
+        const [amountStr, secretStr, leafIndexStr] = result.toString().split(':');
+        await this.#bridgedFeeJuice.set(`${recipient.toString()}:stackPointer`, Buffer.from([
+            --stackPointer
+        ]));
+        log(`Retrieved ${amountStr} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+        return {
+            amount: BigInt(amountStr),
+            secret: secretStr,
+            leafIndex: BigInt(leafIndexStr)
+        };
+    }
+    async storeAccount(address, { type, secretKey, salt, alias, publicKey }, log) {
+        if (alias) {
+            await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+        }
+        await this.#accounts.set(`${address.toString()}:type`, Buffer.from(type));
+        await this.#accounts.set(`${address.toString()}:sk`, secretKey.toBuffer());
+        await this.#accounts.set(`${address.toString()}:salt`, salt.toBuffer());
+        if (type === 'ecdsasecp256r1ssh' && publicKey) {
+            const publicSigningKey = extractECDSAPublicKeyFromBase64String(publicKey);
+            await this.storeAccountMetadata(address, 'publicSigningKey', publicSigningKey);
+        }
+        await this.#aliases.set('accounts:last', Buffer.from(address.toString()));
+        log(`Account stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+        await this.refreshAliasCache();
+    }
+    async storeSender(address, alias, log) {
+        await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+        log(`Account stored in database with alias ${alias} as a sender`);
+        await this.refreshAliasCache();
+    }
+    async storeContract(address, artifactPath, log, alias) {
+        if (alias) {
+            await this.#aliases.set(`contracts:${alias}`, Buffer.from(address.toString()));
+            await this.#aliases.set(`artifacts:${alias}`, Buffer.from(artifactPath));
+        }
+        await this.#aliases.set(`contracts:last`, Buffer.from(address.toString()));
+        await this.#aliases.set(`artifacts:last`, Buffer.from(artifactPath));
+        await this.#aliases.set(`artifacts:${address.toString()}`, Buffer.from(artifactPath));
+        log(`Contract stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+        await this.refreshAliasCache();
+    }
+    async storeAuthwitness(authWit, log, alias) {
+        if (alias) {
+            await this.#aliases.set(`authwits:${alias}`, Buffer.from(authWit.toString()));
+        }
+        await this.#aliases.set(`authwits:last`, Buffer.from(authWit.toString()));
+        log(`Authorization witness stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+        await this.refreshAliasCache();
+    }
+    async storeTx({ txHash, nonce, cancellable, gasSettings }, log, alias) {
+        if (alias) {
+            await this.#aliases.set(`transactions:${alias}`, Buffer.from(txHash.toString()));
+        }
+        await this.#transactions.set(`${txHash.toString()}:nonce`, nonce.toBuffer());
+        await this.#transactions.set(`${txHash.toString()}:cancellable`, Buffer.from(cancellable ? 'true' : 'false'));
+        await this.#transactions.set(`${txHash.toString()}:gasSettings`, gasSettings.toBuffer());
+        await this.#aliases.set(`transactions:last`, Buffer.from(txHash.toString()));
+        log(`Transaction hash stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+        await this.refreshAliasCache();
+    }
+    async retrieveTxData(txHash) {
+        const nonceBuffer = await this.#transactions.getAsync(`${txHash.toString()}:nonce`);
+        if (!nonceBuffer) {
+            throw new Error(`Could not find ${txHash.toString()}:nonce. Transaction with hash "${txHash.toString()}" does not exist on this wallet.`);
+        }
+        const nonce = Fr.fromBuffer(nonceBuffer);
+        const cancellable = (await this.#transactions.getAsync(`${txHash.toString()}:cancellable`)).toString() === 'true';
+        const gasBuffer = await this.#transactions.getAsync(`${txHash.toString()}:gasSettings`);
+        return {
+            txHash,
+            nonce,
+            cancellable,
+            gasSettings: GasSettings.fromBuffer(gasBuffer)
+        };
+    }
+    tryRetrieveAlias(arg) {
+        try {
+            return this.retrieveAliasFromCache(arg);
+        } catch (e) {
+            return arg;
+        }
+    }
+    retrieveAliasFromCache(arg) {
+        if (Aliases.find((alias)=>arg.startsWith(`${alias}:`))) {
+            const [type, ...alias] = arg.split(':');
+            const aliasKey = `${type}:${alias.join(':') ?? 'last'}`;
+            const data = this.aliasCache.get(aliasKey);
+            if (!data) {
+                throw new Error(`Could not find alias ${arg}`);
+            }
+            return data.toString();
+        } else {
+            throw new Error(`Aliases must start with one of ${Aliases.join(', ')}`);
+        }
+    }
+    async retrieveAlias(arg) {
+        if (Aliases.find((alias)=>arg.startsWith(`${alias}:`))) {
+            const [type, ...alias] = arg.split(':');
+            const data = await this.#aliases.getAsync(`${type}:${alias.join(':') ?? 'last'}`);
+            if (!data) {
+                throw new Error(`Could not find alias ${arg}`);
+            }
+            return data.toString();
+        } else {
+            throw new Error(`Aliases must start with one of ${Aliases.join(', ')}`);
+        }
+    }
+    async listAliases(type) {
+        const result = [];
+        if (type && !Aliases.includes(type)) {
+            throw new Error(`Unknown alias type ${type}`);
+        }
+        for await (const [key, value] of this.#aliases.entriesAsync()){
+            if (!type || key.startsWith(`${type}:`)) {
+                result.push({
+                    key,
+                    value: value.toString()
+                });
+            }
+        }
+        return result;
+    }
+    async storeAccountMetadata(aliasOrAddress, metadataKey, metadata) {
+        const { address } = await this.retrieveAccount(aliasOrAddress);
+        await this.#accounts.set(`${address.toString()}:${metadataKey}`, metadata);
+    }
+    async retrieveAccountMetadata(aliasOrAddress, metadataKey) {
+        const { address } = await this.retrieveAccount(aliasOrAddress);
+        const result = await this.#accounts.getAsync(`${address.toString()}:${metadataKey}`);
+        if (!result) {
+            throw new Error(`Could not find metadata with key ${metadataKey} for account ${aliasOrAddress}`);
+        }
+        return result;
+    }
+    async retrieveAccount(address) {
+        const secretKeyBuffer = await this.#accounts.getAsync(`${address.toString()}:sk`);
+        if (!secretKeyBuffer) {
+            throw new Error(`Could not find ${address}:sk. Account "${address.toString}" does not exist on this wallet.`);
+        }
+        const secretKey = Fr.fromBuffer(secretKeyBuffer);
+        const salt = Fr.fromBuffer(await this.#accounts.getAsync(`${address.toString()}:salt`));
+        const type = (await this.#accounts.getAsync(`${address.toString()}:type`)).toString('utf8');
+        return {
+            address,
+            secretKey,
+            salt,
+            type
+        };
+    }
+    async storeAlias(type, key, value, log) {
+        await this.#aliases.set(`${type}:${key}`, value);
+        await this.refreshAliasCache();
+        log(`Data stored in database with alias ${type}:${key}`);
+        await this.refreshAliasCache();
+    }
+}

package/dest/utils/accounts.d.ts

@@ -0,0 +1,11 @@
+import type { AccountManager, AccountWalletWithSecretKey } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { WalletDB } from '../storage/wallet_db.js';
+export declare const AccountTypes: readonly ["schnorr", "ecdsasecp256r1ssh", "ecdsasecp256k1"];
+export type AccountType = (typeof AccountTypes)[number];
+export declare function createOrRetrieveAccount(pxe: PXE, address?: AztecAddress, db?: WalletDB, secretKey?: Fr, type?: AccountType, salt?: Fr, publicKey?: string | undefined): Promise<AccountManager>;
+export declare function addScopeToWallet(wallet: AccountWalletWithSecretKey, scope: AztecAddress, db?: WalletDB): Promise<void>;
+export declare function getWalletWithScopes(account: AccountManager, db?: WalletDB): Promise<AccountWalletWithSecretKey>;
+//# sourceMappingURL=accounts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/utils/accounts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD,eAAO,MAAM,YAAY,6DAA8D,CAAC;AACxF,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,GAAG,EACR,OAAO,CAAC,EAAE,YAAY,EACtB,EAAE,CAAC,EAAE,QAAQ,EACb,SAAS,CAAC,EAAE,EAAE,EACd,IAAI,GAAE,WAAuB,EAC7B,IAAI,CAAC,EAAE,EAAE,EACT,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAAC,cAAc,CAAC,CAkDzB;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,0BAA0B,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,QAAQ,iBAU5G;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,CAAC,EAAE,QAAQ,uCAgB/E"}

package/dest/utils/accounts.js

@@ -0,0 +1,87 @@
+import { getIdentities } from '@aztec/accounts/utils';
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
+export const AccountTypes = [
+    'schnorr',
+    'ecdsasecp256r1ssh',
+    'ecdsasecp256k1'
+];
+export async function createOrRetrieveAccount(pxe, address, db, secretKey, type = 'schnorr', salt, publicKey) {
+    let account;
+    salt ??= Fr.ZERO;
+    if (db && address) {
+        ({ type, secretKey, salt } = await db.retrieveAccount(address));
+    }
+    if (!salt) {
+        throw new Error('Cannot retrieve/create wallet without salt');
+    }
+    if (!secretKey) {
+        throw new Error('Cannot retrieve/create wallet without secret key');
+    }
+    switch(type){
+        case 'schnorr':
+            {
+                const { getSchnorrAccount } = await import('@aztec/accounts/schnorr');
+                account = getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt);
+                break;
+            }
+        case 'ecdsasecp256r1ssh':
+            {
+                let publicSigningKey;
+                if (db && address) {
+                    publicSigningKey = await db.retrieveAccountMetadata(address, 'publicSigningKey');
+                } else if (publicKey) {
+                    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`);
+                    }
+                    publicSigningKey = extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
+                } else {
+                    throw new Error('Public key must be provided for ECDSA SSH account');
+                }
+                const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa');
+                account = getEcdsaRSSHAccount(pxe, secretKey, publicSigningKey, salt);
+                break;
+            }
+        default:
+            {
+                throw new Error(`Unsupported account type: ${type}`);
+            }
+    }
+    return account;
+}
+export async function addScopeToWallet(wallet, scope, db) {
+    const address = wallet.getAddress().toString();
+    const currentScopes = wallet.getScopes() ?? [];
+    const deduplicatedScopes = Array.from(new Set([
+        address,
+        ...currentScopes,
+        scope
+    ].map((scope)=>scope.toString())).values());
+    if (db) {
+        await db.storeAccountMetadata(wallet.getAddress(), 'scopes', Buffer.from(deduplicatedScopes.join(',')));
+    }
+    wallet.setScopes(deduplicatedScopes.map((scope)=>AztecAddress.fromString(scope)));
+}
+export async function getWalletWithScopes(account, db) {
+    const wallet = await account.getWallet();
+    if (db) {
+        const address = wallet.getAddress().toString();
+        let storedScopes = [];
+        try {
+            storedScopes = (await db.retrieveAccountMetadata(wallet.getAddress(), 'scopes') ?? '').toString().split(',');
+        // eslint-disable-next-line no-empty
+        } catch  {}
+        const currentScopes = wallet.getScopes()?.map((scopes)=>scopes.toString()) ?? [];
+        const deduplicatedScopes = Array.from(new Set([
+            address,
+            ...currentScopes,
+            ...storedScopes
+        ]).values()).map((scope)=>AztecAddress.fromString(scope));
+        wallet.setScopes(deduplicatedScopes);
+    }
+    return wallet;
+}

package/dest/utils/ecdsa.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+export declare function extractECDSAPublicKeyFromBase64String(base64PublicKey: string): Buffer;
+//# sourceMappingURL=ecdsa.d.ts.map

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,41 @@
+import { type AccountWallet, type DeployAccountOptions, type FeePaymentMethod, type PXE, type SendMethodOptions } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+import { GasFees, GasSettings } from '@aztec/stdlib/gas';
+import { Option } from 'commander';
+import type { WalletDB } from '../../storage/wallet_db.js';
+export type CliFeeArgs = {
+    estimateGasOnly: boolean;
+    gasLimits?: string;
+    payment?: string;
+    maxFeesPerGas?: string;
+    maxPriorityFeesPerGas?: string;
+    estimateGas?: boolean;
+};
+export interface IFeeOpts {
+    estimateOnly: boolean;
+    gasSettings: GasSettings;
+    toSendOpts(sender: AccountWallet): Promise<SendMethodOptions>;
+    toDeployAccountOpts(sender: AccountWallet): Promise<DeployAccountOptions>;
+}
+export declare function printGasEstimates(feeOpts: IFeeOpts, gasEstimates: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>, log: LogFn): void;
+export declare class FeeOpts implements IFeeOpts {
+    estimateOnly: boolean;
+    gasSettings: GasSettings;
+    private paymentMethodFactory;
+    private getDeployWallet;
+    private estimateGas;
+    constructor(estimateOnly: boolean, gasSettings: GasSettings, paymentMethodFactory: (sender: AccountWallet) => Promise<FeePaymentMethod>, getDeployWallet: (sender: AccountWallet, paymentMethod: FeePaymentMethod) => Promise<AccountWallet | undefined>, estimateGas: boolean);
+    toSendOpts(sender: AccountWallet): Promise<SendMethodOptions>;
+    toDeployAccountOpts(sender: AccountWallet): Promise<DeployAccountOptions>;
+    static paymentMethodOption(): Option;
+    static getOptions(): Option[];
+    static fromCli(args: CliFeeArgs, pxe: PXE, log: LogFn, db?: WalletDB): Promise<FeeOpts>;
+}
+export declare class FeeOptsWithFeePayer extends FeeOpts {
+    static paymentMethodOption(): Option;
+    static getOptions(): Option[];
+    static fromCli(args: CliFeeArgs, pxe: PXE, log: LogFn, db?: WalletDB): Promise<FeeOptsWithFeePayer>;
+}
+export declare function parsePaymentMethod(payment: string, allowCustomFeePayer: boolean, log: LogFn, db?: WalletDB): (sender: AccountWallet) => Promise<FeePaymentMethod>;
+export declare function parseGasFees(gasFees: string): GasFees;
+//# sourceMappingURL=fees.d.ts.map

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,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAEzB,KAAK,gBAAgB,EACrB,KAAK,GAAG,EACR,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAO,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE9D,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAI3D,MAAM,MAAM,UAAU,GAAG;IACvB,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;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC9D,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAC3E;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,QAAQ,EACjB,YAAY,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,mBAAmB,CAAC,EAClE,GAAG,EAAE,KAAK,QAIX;AAuGD,qBAAa,OAAQ,YAAW,QAAQ;IAE7B,YAAY,EAAE,OAAO;IACrB,WAAW,EAAE,WAAW;IAC/B,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,WAAW;gBAPZ,YAAY,EAAE,OAAO,EACrB,WAAW,EAAE,WAAW,EACvB,oBAAoB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,gBAAgB,CAAC,EAC1E,eAAe,EAAE,CACvB,MAAM,EAAE,aAAa,EACrB,aAAa,EAAE,gBAAgB,KAC5B,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,EAC/B,WAAW,EAAE,OAAO;IAGxB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAU7D,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAa/E,MAAM,CAAC,mBAAmB;IAI1B,MAAM,CAAC,UAAU;WAIJ,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,QAAQ;CAsB3E;AAED,qBAAa,mBAAoB,SAAQ,OAAO;WAC9B,mBAAmB;WAInB,UAAU;WAIJ,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,QAAQ;CA2BpF;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,mBAAmB,EAAE,OAAO,EAC5B,GAAG,EAAE,KAAK,EACV,EAAE,CAAC,EAAE,QAAQ,GACZ,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAwEtD;AAsBD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAerD"}

package/dest/utils/options/fees.js

@@ -0,0 +1,283 @@
+import { FeeJuicePaymentMethod } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
+import { Option } from 'commander';
+import { createOrRetrieveAccount } from '../accounts.js';
+import { aliasedAddressParser } from './options.js';
+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.default({
+        ...estimate,
+        maxFeesPerGas
+    }).getFeeLimit().toBigInt();
+}
+async function parseGasSettings(args, pxe) {
+    const gasLimits = args.gasLimits ? parseGasLimits(args.gasLimits) : {};
+    const maxFeesPerGas = args.maxFeesPerGas ? parseGasFees(args.maxFeesPerGas) : await pxe.getCurrentBaseFees();
+    const maxPriorityFeesPerGas = args.maxPriorityFeesPerGas ? parseGasFees(args.maxPriorityFeesPerGas) : undefined;
+    return GasSettings.default({
+        ...gasLimits,
+        maxFeesPerGas,
+        maxPriorityFeesPerGas
+    });
+}
+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')}` : '';
+}
+function getFeePaymentMethodParams(allowCustomFeePayer) {
+    const feePayer = allowCustomFeePayer ? {
+        type: 'address',
+        description: 'The account paying the fee.'
+    } : undefined;
+    return {
+        method: {
+            type: 'name',
+            description: 'Valid values: "fee_juice", "fpc-public", "fpc-private".',
+            default: 'fee_juice'
+        },
+        ...feePayer ? {
+            feePayer
+        } : {},
+        asset: {
+            type: 'address',
+            description: 'The asset used for fee payment. Not required for the "fee_juice" method.'
+        },
+        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.'
+        },
+        feeRecipient: {
+            type: 'string',
+            description: 'Recipient of the fee.'
+        }
+    };
+}
+function getPaymentMethodOption(allowCustomFeePayer) {
+    const params = getFeePaymentMethodParams(allowCustomFeePayer);
+    const paramList = Object.keys(params).map((name)=>`${name}=${params[name].type}`);
+    return new Option(`--payment <${paramList.join(',')}>`, `Fee payment method and arguments.${printOptionParams(params)}`);
+}
+function getFeeOptions(allowCustomFeePayer) {
+    return [
+        getPaymentMethodOption(allowCustomFeePayer),
+        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('--no-estimate-gas', 'Whether to automatically estimate gas limits for the tx.'),
+        new Option('--estimate-gas-only', 'Only report gas estimation for the tx, do not send it.')
+    ];
+}
+export class FeeOpts {
+    estimateOnly;
+    gasSettings;
+    paymentMethodFactory;
+    getDeployWallet;
+    estimateGas;
+    constructor(estimateOnly, gasSettings, paymentMethodFactory, getDeployWallet, estimateGas){
+        this.estimateOnly = estimateOnly;
+        this.gasSettings = gasSettings;
+        this.paymentMethodFactory = paymentMethodFactory;
+        this.getDeployWallet = getDeployWallet;
+        this.estimateGas = estimateGas;
+    }
+    async toSendOpts(sender) {
+        return {
+            fee: {
+                estimateGas: this.estimateGas,
+                gasSettings: this.gasSettings,
+                paymentMethod: await this.paymentMethodFactory(sender)
+            }
+        };
+    }
+    async toDeployAccountOpts(sender) {
+        const paymentMethod = await this.paymentMethodFactory(sender);
+        const deployWallet = await this.getDeployWallet(sender, paymentMethod);
+        return {
+            deployWallet,
+            fee: {
+                estimateGas: this.estimateGas,
+                gasSettings: this.gasSettings,
+                paymentMethod
+            }
+        };
+    }
+    static paymentMethodOption() {
+        return getPaymentMethodOption(false);
+    }
+    static getOptions() {
+        return getFeeOptions(false);
+    }
+    static async fromCli(args, pxe, log, db) {
+        const estimateOnly = args.estimateGasOnly;
+        const gasSettings = await parseGasSettings(args, pxe);
+        const defaultPaymentMethod = async (sender)=>{
+            const { FeeJuicePaymentMethod } = await import('@aztec/aztec.js/fee');
+            return new FeeJuicePaymentMethod(sender.getAddress());
+        };
+        const getDeployWallet = ()=>{
+            // Returns undefined. The sender's wallet will be used by default.
+            return Promise.resolve(undefined);
+        };
+        return new FeeOpts(estimateOnly, gasSettings, args.payment ? parsePaymentMethod(args.payment, false, log, db) : defaultPaymentMethod, getDeployWallet, !!args.estimateGas);
+    }
+}
+export class FeeOptsWithFeePayer extends FeeOpts {
+    static paymentMethodOption() {
+        return getPaymentMethodOption(true);
+    }
+    static getOptions() {
+        return getFeeOptions(true);
+    }
+    static async fromCli(args, pxe, log, db) {
+        const estimateOnly = args.estimateGasOnly;
+        const gasSettings = await parseGasSettings(args, pxe);
+        const defaultPaymentMethod = async (sender)=>{
+            const { FeeJuicePaymentMethod } = await import('@aztec/aztec.js/fee');
+            return new FeeJuicePaymentMethod(sender.getAddress());
+        };
+        const getDeployWallet = async (sender, paymentMethod)=>{
+            if (paymentMethod instanceof FeeJuicePaymentMethod) {
+                const feePayer = await paymentMethod.getFeePayer();
+                if (!sender.getAddress().equals(feePayer)) {
+                    return (await createOrRetrieveAccount(pxe, feePayer, db)).getWallet();
+                }
+            }
+            return undefined;
+        };
+        return new FeeOptsWithFeePayer(estimateOnly, gasSettings, args.payment ? parsePaymentMethod(args.payment, true, log, db) : defaultPaymentMethod, getDeployWallet, !!args.estimateGas);
+    }
+}
+export function parsePaymentMethod(payment, allowCustomFeePayer, log, db) {
+    const parsed = payment.split(',').reduce((acc, item)=>{
+        const [dimension, value] = item.split('=');
+        acc[dimension] = value ?? 1;
+        return acc;
+    }, {});
+    const getFpcOpts = (parsed, db)=>{
+        if (!parsed.fpc) {
+            throw new Error('Missing "fpc" in payment option');
+        }
+        if (!parsed.asset) {
+            throw new Error('Missing "asset" in payment option');
+        }
+        const fpc = aliasedAddressParser('contracts', parsed.fpc, db);
+        return [
+            AztecAddress.fromString(parsed.asset),
+            fpc
+        ];
+    };
+    return async (sender)=>{
+        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 } = await db.popBridgedFeeJuice(sender.getAddress(), log));
+                        } else {
+                            ({ claimAmount, claimSecret, messageLeafIndex } = parsed);
+                        }
+                        log(`Using Fee Juice for fee payments with claim for ${claimAmount} tokens`);
+                        const { FeeJuicePaymentMethodWithClaim } = await import('@aztec/aztec.js/fee');
+                        return new FeeJuicePaymentMethodWithClaim(sender, {
+                            claimAmount: (typeof claimAmount === 'string' ? Fr.fromHexString(claimAmount) : new Fr(claimAmount)).toBigInt(),
+                            claimSecret: Fr.fromHexString(claimSecret),
+                            messageLeafIndex: BigInt(messageLeafIndex)
+                        });
+                    } else {
+                        log(`Using Fee Juice for fee payment`);
+                        const { FeeJuicePaymentMethod } = await import('@aztec/aztec.js/fee');
+                        const feePayer = parsed.feePayer && allowCustomFeePayer ? aliasedAddressParser('accounts', parsed.feePayer, db) : sender.getAddress();
+                        return new FeeJuicePaymentMethod(feePayer);
+                    }
+                }
+            case 'fpc-public':
+                {
+                    const [asset, fpc] = getFpcOpts(parsed, db);
+                    log(`Using public fee payment with asset ${asset} via paymaster ${fpc}`);
+                    const { PublicFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+                    return new PublicFeePaymentMethod(fpc, sender);
+                }
+            case 'fpc-private':
+                {
+                    const [asset, fpc] = getFpcOpts(parsed, db);
+                    log(`Using private fee payment with asset ${asset} via paymaster ${fpc}`);
+                    const { PrivateFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+                    return new PrivateFeePaymentMethod(fpc, sender);
+                }
+            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);
+}

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

@@ -0,0 +1,3 @@
+export * from './fees.js';
+export * from './options.js';
+//# sourceMappingURL=index.d.ts.map