@aztec-labs/aztec.js 6.0.0-nightly.20260829

package/dest/utils/cross_chain.js

@@ -0,0 +1,26 @@
+import { retryUntil } from '@aztec-labs/foundation/retry';
+/**
+ * Waits for the L1 to L2 message to be ready to be consumed.
+ * @param node - Aztec node instance used to obtain the information about the message
+ * @param l1ToL2MessageHash - Hash of the L1 to L2 message
+ * @param opts - Options
+ */ export function waitForL1ToL2MessageReady(node, l1ToL2MessageHash, opts) {
+    return retryUntil(()=>isL1ToL2MessageReady(node, l1ToL2MessageHash, opts.chainTip), `L1 to L2 message ${l1ToL2MessageHash.toString()} ready`, opts.timeoutSeconds, 1);
+}
+/**
+ * Returns whether the L1 to L2 message is ready to be consumed.
+ * @param node - Aztec node instance used to obtain the information about the message
+ * @param l1ToL2MessageHash - Hash of the L1 to L2 message
+ * @param chainTip - Chain tip to evaluate readiness against. Defaults to `'latest'`. Pass the tip the consuming PXE
+ * syncs to (e.g. `'proven'`) so readiness is checked at the block the transaction simulation will anchor to.
+ * @returns True if the message is ready to be consumed, false otherwise
+ */ export async function isL1ToL2MessageReady(node, l1ToL2MessageHash, chainTip = 'latest') {
+    const messageIndex = await node.getL1ToL2MessageIndex(l1ToL2MessageHash);
+    if (messageIndex === undefined) {
+        return false;
+    }
+    // Blocks consume L1-to-L2 messages in Inbox order into consecutive leaves of the message tree, so the message is
+    // available at a tip exactly when that tip's tree has grown past the message's leaf index.
+    const block = await node.getBlockData(chainTip);
+    return block !== undefined && messageIndex < BigInt(block.header.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+}

package/dest/utils/fee_juice.d.ts

@@ -0,0 +1,8 @@
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+/**
+ * Returns the owner's fee juice balance.
+ * Note: This is used only e2e_local_network_example test. TODO: Consider nuking.
+ */
+export declare function getFeeJuiceBalance(owner: AztecAddress, node: AztecNode): Promise<bigint>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlX2p1aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvZmVlX2p1aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRXJFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBRXRFOzs7R0FHRztBQUNILHdCQUFzQixrQkFBa0IsQ0FBQyxLQUFLLEVBQUUsWUFBWSxFQUFFLElBQUksRUFBRSxTQUFTLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUc5RiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"fee_juice.d.ts","sourceRoot":"","sources":["../../src/utils/fee_juice.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAEtE;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAG9F"}

package/dest/utils/fee_juice.js

@@ -0,0 +1,10 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { ProtocolContractAddress } from '@aztec-labs/protocol-contracts';
+import { deriveStorageSlotInMap } from '@aztec-labs/stdlib/hash';
+/**
+ * Returns the owner's fee juice balance.
+ * Note: This is used only e2e_local_network_example test. TODO: Consider nuking.
+ */ export async function getFeeJuiceBalance(owner, node) {
+    const slot = await deriveStorageSlotInMap(new Fr(1), owner);
+    return (await node.getPublicStorageAt('latest', ProtocolContractAddress.FeeJuice, slot)).toBigInt();
+}

package/dest/utils/field_compressed_string.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The representation of a FieldCompressedString in aztec.nr
+ */
+interface NoirFieldCompressedString {
+    /**
+     * The field value of the string
+     */
+    value: bigint;
+}
+/**
+ * This turns
+ * @param field - The field that contains the string
+ * @returns - the string that is decoded from the field
+ */
+export declare const readFieldCompressedString: (field: NoirFieldCompressedString) => string;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGRfY29tcHJlc3NlZF9zdHJpbmcuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9maWVsZF9jb21wcmVzc2VkX3N0cmluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7R0FFRztBQUNILFVBQVUseUJBQXlCO0lBQ2pDOztPQUVHO0lBQ0gsS0FBSyxFQUFFLE1BQU0sQ0FBQztDQUNmO0FBQ0Q7Ozs7R0FJRztBQUNILGVBQU8sTUFBTSx5QkFBeUIsOENBVXJDLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"field_compressed_string.d.ts","sourceRoot":"","sources":["../../src/utils/field_compressed_string.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,UAAU,yBAAyB;IACjC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AACD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,8CAUrC,CAAC"}

package/dest/utils/field_compressed_string.js

@@ -0,0 +1,15 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+/**
+ * This turns
+ * @param field - The field that contains the string
+ * @returns - the string that is decoded from the field
+ */ export const readFieldCompressedString = (field)=>{
+    const vals = Array.from(new Fr(field.value).toBuffer());
+    let str = '';
+    for(let i = 0; i < vals.length; i++){
+        if (vals[i] != 0) {
+            str += String.fromCharCode(Number(vals[i]));
+        }
+    }
+    return str;
+};

package/dest/utils/node.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+import type { TxHash, TxReceipt } from '@aztec-labs/stdlib/tx';
+import { type WaitOpts } from '../contract/wait_opts.js';
+/**
+ * Waits for an Aztec node to become reachable, polling {@link AztecNode.getNodeInfo} until it succeeds.
+ * @param node - The Aztec node to contact.
+ * @param logger - Optional logger for polling progress.
+ * @param opts - Optional timeout and interval (in seconds). `timeout` defaults to {@link DefaultWaitOpts.timeout};
+ * pass `timeout: 0` to wait indefinitely.
+ * @throws TimeoutError if the node stays unreachable past the timeout.
+ */
+export declare const waitForNode: (node: AztecNode, logger?: Logger | undefined, opts?: Pick<WaitOpts, "interval" | "timeout"> | undefined) => Promise<void>;
+/**
+ * Waits for a transaction to be mined and returns its receipt.
+ * @param node - The Aztec node to query for transaction status
+ * @param txHash - The hash of the transaction to wait for
+ * @param opts - Optional configuration for waiting behavior
+ * @returns The transaction receipt
+ * @throws If the transaction fails and dontThrowOnRevert is not set
+ */
+export declare function waitForTx(node: AztecNode, txHash: TxHash, opts?: WaitOpts): Promise<TxReceipt>;
+export { createAztecNodeClient, type AztecNode, type AztecNodeClientOptions, } from '@aztec-labs/stdlib/interfaces/client';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL25vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFHekQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDdEUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRy9ELE9BQU8sRUFBbUIsS0FBSyxRQUFRLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUUxRTs7Ozs7OztHQU9HO0FBQ0gsZUFBTyxNQUFNLFdBQVcsNEhBaUJ2QixDQUFDO0FBT0Y7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQixTQUFTLENBQUMsSUFBSSxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLElBQUksQ0FBQyxFQUFFLFFBQVEsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBc0RwRztBQUVELE9BQU8sRUFDTCxxQkFBcUIsRUFDckIsS0FBSyxTQUFTLEVBQ2QsS0FBSyxzQkFBc0IsR0FDNUIsTUFBTSxzQ0FBc0MsQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/utils/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAGzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAG/D,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAE1E;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,4HAiBvB,CAAC;AAOF;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAsDpG;AAED,OAAO,EACL,qBAAqB,EACrB,KAAK,SAAS,EACd,KAAK,sBAAsB,GAC5B,MAAM,sCAAsC,CAAC"}

package/dest/utils/node.js

@@ -0,0 +1,80 @@
+import { retryUntil } from '@aztec-labs/foundation/retry';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import { SortedTxStatuses, TxStatus } from '@aztec-labs/stdlib/tx';
+import { DefaultWaitOpts } from '../contract/wait_opts.js';
+/**
+ * Waits for an Aztec node to become reachable, polling {@link AztecNode.getNodeInfo} until it succeeds.
+ * @param node - The Aztec node to contact.
+ * @param logger - Optional logger for polling progress.
+ * @param opts - Optional timeout and interval (in seconds). `timeout` defaults to {@link DefaultWaitOpts.timeout};
+ * pass `timeout: 0` to wait indefinitely.
+ * @throws TimeoutError if the node stays unreachable past the timeout.
+ */ export const waitForNode = async (node, logger, opts)=>{
+    await retryUntil(async ()=>{
+        try {
+            logger?.verbose('Attempting to contact Aztec node...');
+            await node.getNodeInfo();
+            logger?.verbose('Contacted Aztec node');
+            return true;
+        } catch  {
+            logger?.verbose('Failed to contact Aztec Node');
+        }
+        return undefined;
+    }, 'RPC Get Node Info', opts?.timeout ?? DefaultWaitOpts.timeout, opts?.interval ?? DefaultWaitOpts.interval);
+};
+/** Returns true if the receipt status is at least the desired status level. */ function hasReachedStatus(receipt, desiredStatus) {
+    return SortedTxStatuses.indexOf(receipt.status) >= SortedTxStatuses.indexOf(desiredStatus);
+}
+/**
+ * Waits for a transaction to be mined and returns its receipt.
+ * @param node - The Aztec node to query for transaction status
+ * @param txHash - The hash of the transaction to wait for
+ * @param opts - Optional configuration for waiting behavior
+ * @returns The transaction receipt
+ * @throws If the transaction fails and dontThrowOnRevert is not set
+ */ export async function waitForTx(node, txHash, opts) {
+    const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
+    const waitForStatus = opts?.waitForStatus ?? TxStatus.CHECKPOINTED;
+    const timeout = opts?.timeout ?? DefaultWaitOpts.timeout;
+    // The initial delay counts against the timeout: the deadline is fixed before sleeping, and the sleep never
+    // exceeds it.
+    const deadline = timeout ? {
+        deadline: new Date(Date.now() + timeout * 1000)
+    } : undefined;
+    if (opts?.initialDelay) {
+        const delay = Math.min(opts.initialDelay, timeout ?? Infinity);
+        await sleep(delay * 1000);
+    }
+    // The grace period for DROPPED receipts starts at the first poll, so the initial delay does not consume it.
+    const startTime = Date.now();
+    const receipt = await retryUntil(async ()=>{
+        const txReceipt = await node.getTxReceipt(txHash);
+        // If receipt is not yet available, try again
+        if (txReceipt.isPending()) {
+            return undefined;
+        }
+        // If the tx was "dropped", either return it or ignore based on timing.
+        // We can ignore it at first because the transaction may have been sent to node 1, and now we're asking node 2 for the receipt.
+        // If we don't allow a short grace period, we could incorrectly return a TxReceipt with status DROPPED.
+        if (txReceipt.isDropped()) {
+            const elapsedSeconds = (Date.now() - startTime) / 1000;
+            if (!ignoreDroppedReceiptsFor || elapsedSeconds > ignoreDroppedReceiptsFor) {
+                return txReceipt;
+            }
+            return undefined;
+        }
+        // Check if the receipt has reached the desired status level
+        if (!hasReachedStatus(txReceipt, waitForStatus)) {
+            return undefined;
+        }
+        return txReceipt;
+    }, 'isMined', deadline, opts?.interval ?? DefaultWaitOpts.interval);
+    if (!receipt.isMined()) {
+        throw new Error(`Transaction ${txHash.toString()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`);
+    }
+    if (!receipt.hasExecutionSucceeded() && !opts?.dontThrowOnRevert) {
+        throw new Error(`Transaction ${txHash.toString()} reverted: ${receipt.executionResult}. Reason: ${receipt.error ?? 'unknown'}`);
+    }
+    return receipt;
+}
+export { createAztecNodeClient } from '@aztec-labs/stdlib/interfaces/client';

package/dest/utils/pub_key.d.ts

@@ -0,0 +1,9 @@
+import type { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import type { PublicKey } from '@aztec-labs/stdlib/keys';
+/**
+ * Method for generating a public grumpkin key from a private key.
+ * @param privateKey - The private key.
+ * @returns The generated public key.
+ */
+export declare function generatePublicKey(privateKey: GrumpkinScalar): Promise<PublicKey>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHViX2tleS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3B1Yl9rZXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDN0UsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFekQ7Ozs7R0FJRztBQUNILHdCQUFnQixpQkFBaUIsQ0FBQyxVQUFVLEVBQUUsY0FBYyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FFaEYifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"pub_key.d.ts","sourceRoot":"","sources":["../../src/utils/pub_key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CAEhF"}

package/dest/utils/pub_key.js

@@ -0,0 +1,8 @@
+import { Grumpkin } from '@aztec-labs/foundation/crypto/grumpkin';
+/**
+ * Method for generating a public grumpkin key from a private key.
+ * @param privateKey - The private key.
+ * @returns The generated public key.
+ */ export function generatePublicKey(privateKey) {
+    return Grumpkin.mul(Grumpkin.generator, privateKey);
+}

package/dest/wallet/account_entrypoint_meta_payment_method.d.ts

@@ -0,0 +1,33 @@
+import type { ChainInfo } from '@aztec-labs/entrypoints/interfaces';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { GasSettings } from '@aztec-labs/stdlib/gas';
+import { ExecutionPayload } from '@aztec-labs/stdlib/tx';
+import type { Account } from '../account/account.js';
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+/**
+ * Fee payment method that allows an account contract to pay for its own deployment
+ * It works by rerouting the provided fee payment method through the account's entrypoint,
+ * which sets itself as fee payer. If no payment method is provided, it is assumed the
+ * account will pay with its own fee juice balance.
+ *
+ * Usually, in order to pay fees it is necessary to obtain an ExecutionPayload that encodes the necessary information
+ * that is sent to the user's account entrypoint, that has plumbing to handle it.
+ * If there's no account contract yet (it's being deployed) a MultiCallContract is used, which doesn't have a concept of fees or
+ * how to handle this payload.
+ * HOWEVER, the account contract's entrypoint does, so this method reshapes that fee payload into a call to the account contract entrypoint
+ * being deployed with the original fee payload.
+ *
+ * This class can be seen in action in DeployAccountMethod.ts#getSelfPaymentMethod
+ */
+export declare class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
+    private account;
+    private chainInfo;
+    private paymentMethod?;
+    private feeEntrypointOptions?;
+    constructor(account: Account, chainInfo: ChainInfo, paymentMethod?: FeePaymentMethod | undefined, feeEntrypointOptions?: any);
+    getAsset(): Promise<AztecAddress>;
+    getExecutionPayload(): Promise<ExecutionPayload>;
+    getFeePayer(): Promise<AztecAddress>;
+    getGasSettings(): GasSettings | undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9lbnRyeXBvaW50X21ldGFfcGF5bWVudF9tZXRob2QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93YWxsZXQvYWNjb3VudF9lbnRyeXBvaW50X21ldGFfcGF5bWVudF9tZXRob2QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFFcEUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzFELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFckU7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFDSCxxQkFBYSxrQ0FBbUMsWUFBVyxnQkFBZ0I7SUFFdkUsT0FBTyxDQUFDLE9BQU87SUFDZixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsYUFBYSxDQUFDO0lBQ3RCLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQztJQUovQixZQUNVLE9BQU8sRUFBRSxPQUFPLEVBQ2hCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGFBQWEsQ0FBQyw4QkFBa0IsRUFDaEMsb0JBQW9CLENBQUMsS0FBSyxFQUNoQztJQUVKLFFBQVEsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLENBRWhDO0lBRUssbUJBQW1CLElBQUksT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBNkJyRDtJQUVELFdBQVcsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLENBRW5DO0lBRUQsY0FBYyxJQUFJLFdBQVcsR0FBRyxTQUFTLENBRXhDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"account_entrypoint_meta_payment_method.d.ts","sourceRoot":"","sources":["../../src/wallet/account_entrypoint_meta_payment_method.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAEpE,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kCAAmC,YAAW,gBAAgB;IAEvE,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,oBAAoB,CAAC;IAJ/B,YACU,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,SAAS,EACpB,aAAa,CAAC,8BAAkB,EAChC,oBAAoB,CAAC,KAAK,EAChC;IAEJ,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC,CAEhC;IAEK,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CA6BrD;IAED,WAAW,IAAI,OAAO,CAAC,YAAY,CAAC,CAEnC;IAED,cAAc,IAAI,WAAW,GAAG,SAAS,CAExC;CACF"}

package/dest/wallet/account_entrypoint_meta_payment_method.js

@@ -0,0 +1,63 @@
+import { AccountFeePaymentMethodOptions } from '@aztec-labs/entrypoints/account';
+import { ProtocolContractAddress } from '@aztec-labs/protocol-contracts';
+import { ExecutionPayload } from '@aztec-labs/stdlib/tx';
+/**
+ * Fee payment method that allows an account contract to pay for its own deployment
+ * It works by rerouting the provided fee payment method through the account's entrypoint,
+ * which sets itself as fee payer. If no payment method is provided, it is assumed the
+ * account will pay with its own fee juice balance.
+ *
+ * Usually, in order to pay fees it is necessary to obtain an ExecutionPayload that encodes the necessary information
+ * that is sent to the user's account entrypoint, that has plumbing to handle it.
+ * If there's no account contract yet (it's being deployed) a MultiCallContract is used, which doesn't have a concept of fees or
+ * how to handle this payload.
+ * HOWEVER, the account contract's entrypoint does, so this method reshapes that fee payload into a call to the account contract entrypoint
+ * being deployed with the original fee payload.
+ *
+ * This class can be seen in action in DeployAccountMethod.ts#getSelfPaymentMethod
+ */ export class AccountEntrypointMetaPaymentMethod {
+    account;
+    chainInfo;
+    paymentMethod;
+    feeEntrypointOptions;
+    constructor(account, chainInfo, paymentMethod, feeEntrypointOptions){
+        this.account = account;
+        this.chainInfo = chainInfo;
+        this.paymentMethod = paymentMethod;
+        this.feeEntrypointOptions = feeEntrypointOptions;
+    }
+    getAsset() {
+        return this.paymentMethod?.getAsset() ?? Promise.resolve(ProtocolContractAddress.FeeJuice);
+    }
+    async getExecutionPayload() {
+        // Get the execution payload for the fee
+        const innerPayload = await this.paymentMethod?.getExecutionPayload() ?? ExecutionPayload.empty();
+        // If no fee entrypoint options were provided, compute them based on the wrapped payment method
+        // This mimics how the actual account contract works when invoked directly:
+        // - If we are the fee payer, are there calls in the inner payload? In that case, those calls can
+        //   only be claiming fee juice, so we use FEE_JUICE_WITH_CLAIM
+        // - If we are the fee payer, but there are no calls, then we assume the account already has
+        //   fee juice and can pay directly with PREEXISTING_FEE_JUICE
+        // - If we are not the fee payer, then EXTERNAL is used
+        let options = this.feeEntrypointOptions;
+        if (!options) {
+            const feePayer = await this.paymentMethod?.getFeePayer() ?? this.account.getAddress();
+            const isFeePayer = feePayer.equals(this.account.getAddress());
+            let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
+            if (isFeePayer) {
+                accountFeePaymentMethodOptions = innerPayload.calls.length === 0 ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
+            }
+            options = {
+                feePaymentMethodOptions: accountFeePaymentMethodOptions
+            };
+        }
+        // Use the generic wrapping mechanism from the account interface
+        return this.account.wrapExecutionPayload(innerPayload, this.chainInfo, options);
+    }
+    getFeePayer() {
+        return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.account.getAddress());
+    }
+    getGasSettings() {
+        return this.paymentMethod?.getGasSettings();
+    }
+}

package/dest/wallet/account_manager.d.ts

@@ -0,0 +1,73 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec-labs/stdlib/contract';
+import type { PublicKeys } from '@aztec-labs/stdlib/keys';
+import type { AccountContract } from '../account/account_contract.js';
+import type { Account, Salt } from '../account/index.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
+import type { Wallet } from './wallet.js';
+/**
+ * Optional overrides passed to {@link AccountManager.create}.
+ */
+export interface AccountManagerCreateOptions {
+    /** Contract instantiation salt. Defaults to a random `Fr`. */
+    salt?: Salt;
+    /**
+     * Commitment to the contract's immutable storage values. Folded into the salted initialization
+     * hash, so a non-zero value affects the derived address. Defaults to `Fr.ZERO`.
+     */
+    immutablesHash?: Fr;
+    /** Address recorded as the instance deployer. Defaults to `AztecAddress.ZERO`. */
+    deployer?: AztecAddress;
+}
+/**
+ * Manages a user account. Provides methods for calculating the account's address and other related data,
+ * plus a helper to return a preconfigured deploy method.
+ */
+export declare class AccountManager {
+    private wallet;
+    private secretKey;
+    private accountContract;
+    private instance;
+    private constructor();
+    static create(wallet: Wallet, secretKey: Fr, accountContract: AccountContract, opts?: AccountManagerCreateOptions): Promise<AccountManager>;
+    protected getPublicKeys(): PublicKeys;
+    protected getPublicKeysHash(): Promise<Fr>;
+    /**
+     * Gets the calculated complete address associated with this account.
+     * Does not require the account to have been published for public execution.
+     * @returns The address, partial address, and encryption public key.
+     */
+    getCompleteAddress(): Promise<CompleteAddress>;
+    /**
+     * Returns the secret key used to derive the rest of the privacy keys for this contract
+     */
+    getSecretKey(): Fr;
+    get address(): AztecAddress;
+    /**
+     * Returns the contract instance definition associated with this account.
+     * Does not require the account to have been published for public execution.
+     * @returns ContractInstance instance.
+     */
+    getInstance(): ContractInstanceWithAddress;
+    /**
+     * Returns the account (the transaction signer) backed by this account contract. Use it to build and authorize
+     * transactions from this account.
+     */
+    getAccount(): Promise<Account>;
+    /**
+     * Returns the account contract that backs this account.
+     * @returns The account contract
+     */
+    getAccountContract(): AccountContract;
+    /**
+     * Returns a preconfigured deploy method that contains all the necessary function
+     * calls to deploy the account contract.
+     */
+    getDeployMethod(): Promise<DeployAccountMethod>;
+    /**
+     * Returns whether this account contract has an initializer function.
+     */
+    hasInitializer(): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9tYW5hZ2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2FsbGV0L2FjY291bnRfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDckUsT0FBTyxFQUNMLGVBQWUsRUFDZixLQUFLLDJCQUEyQixFQUVqQyxNQUFNLDZCQUE2QixDQUFDO0FBQ3JDLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRzFELE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV6RCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFMUM7O0dBRUc7QUFDSCxNQUFNLFdBQVcsMkJBQTJCO0lBQzFDLDhEQUE4RDtJQUM5RCxJQUFJLENBQUMsRUFBRSxJQUFJLENBQUM7SUFDWjs7O09BR0c7SUFDSCxjQUFjLENBQUMsRUFBRSxFQUFFLENBQUM7SUFDcEIsa0ZBQWtGO0lBQ2xGLFFBQVEsQ0FBQyxFQUFFLFlBQVksQ0FBQztDQUN6QjtBQUVEOzs7R0FHRztBQUNILHFCQUFhLGNBQWM7SUFFdkIsT0FBTyxDQUFDLE1BQU07SUFDZCxPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsZUFBZTtJQUN2QixPQUFPLENBQUMsUUFBUTtJQUpsQixPQUFPLGVBS0g7SUFFSixPQUFhLE1BQU0sQ0FDakIsTUFBTSxFQUFFLE1BQU0sRUFDZCxTQUFTLEVBQUUsRUFBRSxFQUNiLGVBQWUsRUFBRSxlQUFlLEVBQ2hDLElBQUksQ0FBQyxFQUFFLDJCQUEyQiwyQkFxQm5DO0lBRUQsU0FBUyxDQUFDLGFBQWEsSUFBSSxVQUFVLENBRXBDO0lBRUQsU0FBUyxDQUFDLGlCQUFpQixJQUFJLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FFekM7SUFFRDs7OztPQUlHO0lBQ0ksa0JBQWtCLElBQUksT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUVwRDtJQUVEOztPQUVHO0lBQ0ksWUFBWSxPQUVsQjtJQUVELElBQUksT0FBTyxJQUFJLFlBQVksQ0FFMUI7SUFFRDs7OztPQUlHO0lBQ0ksV0FBVyxJQUFJLDJCQUEyQixDQUVoRDtJQUVEOzs7T0FHRztJQUNVLFVBQVUsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLENBRzFDO0lBRUQ7OztPQUdHO0lBQ0gsa0JBQWtCLElBQUksZUFBZSxDQUVwQztJQUVEOzs7T0FHRztJQUNVLGVBQWUsSUFBSSxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0EyQjNEO0lBRUQ7O09BRUc7SUFDVSxjQUFjLHFCQUUxQjtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"account_manager.d.ts","sourceRoot":"","sources":["../../src/wallet/account_manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EACL,eAAe,EACf,KAAK,2BAA2B,EAEjC,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,8DAA8D;IAC9D,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ;;;OAGG;IACH,cAAc,CAAC,EAAE,EAAE,CAAC;IACpB,kFAAkF;IAClF,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB;AAED;;;GAGG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ;IAJlB,OAAO,eAKH;IAEJ,OAAa,MAAM,CACjB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,EAAE,EACb,eAAe,EAAE,eAAe,EAChC,IAAI,CAAC,EAAE,2BAA2B,2BAqBnC;IAED,SAAS,CAAC,aAAa,IAAI,UAAU,CAEpC;IAED,SAAS,CAAC,iBAAiB,IAAI,OAAO,CAAC,EAAE,CAAC,CAEzC;IAED;;;;OAIG;IACI,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC,CAEpD;IAED;;OAEG;IACI,YAAY,OAElB;IAED,IAAI,OAAO,IAAI,YAAY,CAE1B;IAED;;;;OAIG;IACI,WAAW,IAAI,2BAA2B,CAEhD;IAED;;;OAGG;IACU,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC,CAG1C;IAED;;;OAGG;IACH,kBAAkB,IAAI,eAAe,CAEpC;IAED;;;OAGG;IACU,eAAe,IAAI,OAAO,CAAC,mBAAmB,CAAC,CA2B3D;IAED;;OAEG;IACU,cAAc,qBAE1B;CACF"}

package/dest/wallet/account_manager.js

@@ -0,0 +1,102 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { CompleteAddress, getContractInstanceFromInstantiationParams } from '@aztec-labs/stdlib/contract';
+import { deriveKeys } from '@aztec-labs/stdlib/keys';
+import { Contract } from '../contract/contract.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
+/**
+ * Manages a user account. Provides methods for calculating the account's address and other related data,
+ * plus a helper to return a preconfigured deploy method.
+ */ export class AccountManager {
+    wallet;
+    secretKey;
+    accountContract;
+    instance;
+    constructor(wallet, secretKey, accountContract, instance){
+        this.wallet = wallet;
+        this.secretKey = secretKey;
+        this.accountContract = accountContract;
+        this.instance = instance;
+    }
+    static async create(wallet, secretKey, accountContract, opts) {
+        const { publicKeys } = await deriveKeys(secretKey);
+        const salt = opts?.salt !== undefined ? new Fr(opts.salt) : Fr.random();
+        const { constructorName, constructorArgs } = await accountContract.getInitializationFunctionAndArgs() ?? {
+            constructorName: undefined,
+            constructorArgs: undefined
+        };
+        const artifact = await accountContract.getContractArtifact();
+        const instance = await getContractInstanceFromInstantiationParams(artifact, {
+            constructorArtifact: constructorName,
+            constructorArgs,
+            salt,
+            publicKeys,
+            deployer: opts?.deployer,
+            immutablesHash: opts?.immutablesHash ?? await accountContract.getImmutablesHash()
+        });
+        return new AccountManager(wallet, secretKey, accountContract, instance);
+    }
+    getPublicKeys() {
+        return this.instance.publicKeys;
+    }
+    getPublicKeysHash() {
+        return this.getPublicKeys().hash();
+    }
+    /**
+   * Gets the calculated complete address associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @returns The address, partial address, and encryption public key.
+   */ getCompleteAddress() {
+        return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
+    }
+    /**
+   * Returns the secret key used to derive the rest of the privacy keys for this contract
+   */ getSecretKey() {
+        return this.secretKey;
+    }
+    get address() {
+        return this.instance.address;
+    }
+    /**
+   * Returns the contract instance definition associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @returns ContractInstance instance.
+   */ getInstance() {
+        return this.instance;
+    }
+    /**
+   * Returns the account (the transaction signer) backed by this account contract. Use it to build and authorize
+   * transactions from this account.
+   */ async getAccount() {
+        const completeAddress = await this.getCompleteAddress();
+        return this.accountContract.getAccount(completeAddress);
+    }
+    /**
+   * Returns the account contract that backs this account.
+   * @returns The account contract
+   */ getAccountContract() {
+        return this.accountContract;
+    }
+    /**
+   * Returns a preconfigured deploy method that contains all the necessary function
+   * calls to deploy the account contract.
+   */ async getDeployMethod() {
+        const artifact = await this.accountContract.getContractArtifact();
+        if (!await this.hasInitializer()) {
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15576):
+            // there should be a path which enables an account contract's class & instance to be published,
+            // even if the account contract doesn't have an initializer function. This should not throw.
+            throw new Error(`Account contract ${artifact.name} does not have an initializer function to call.`);
+        }
+        const { constructorName, constructorArgs } = await this.accountContract.getInitializationFunctionAndArgs() ?? {
+            constructorName: undefined,
+            constructorArgs: undefined
+        };
+        const account = await this.getAccount();
+        return new DeployAccountMethod(this.getPublicKeys(), this.wallet, artifact, (instance)=>Contract.at(instance.address, artifact, this.wallet), this.instance.salt, this.instance.immutablesHash, account, constructorArgs, constructorName);
+    }
+    /**
+   * Returns whether this account contract has an initializer function.
+   */ async hasInitializer() {
+        return await this.accountContract.getInitializationFunctionAndArgs() !== undefined;
+    }
+}