@aztec/aztec.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/dest/utils/authwit.d.ts

@@ -1,27 +1,33 @@
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
 import { Fr } from '@aztec/foundation/fields';
-import type { FunctionCall } from '@aztec/stdlib/abi';
+import { type FunctionCall } from '@aztec/stdlib/abi';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { TxProfileResult } from '@aztec/stdlib/tx';
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-/** Metadata for the intent */
-export type IntentMetadata = {
-    /** The chain id to approve */
-    chainId: Fr;
-    /** The version to approve  */
-    version: Fr;
-};
+import type { ProfileInteractionOptions, SendInteractionOptions, SimulateInteractionOptions, SimulationReturn } from '../contract/interaction_options.js';
+import type { SentTx } from '../contract/sent_tx.js';
+import type { Wallet } from '../wallet/index.js';
 /** Intent with an inner hash */
 export type IntentInnerHash = {
     /** The consumer   */
     consumer: AztecAddress;
     /** The action to approve */
-    innerHash: Buffer | Fr;
+    innerHash: Buffer<ArrayBuffer> | Fr;
+};
+/** Intent with a call */
+export type CallIntent = {
+    /** The caller to approve  */
+    caller: AztecAddress;
+    /** The call to approve */
+    call: FunctionCall;
 };
-/** Intent with an action */
-export type IntentAction = {
+/** Intent with a ContractFunctionInteraction */
+export type ContractFunctionInteractionCallIntent = {
     /** The caller to approve  */
     caller: AztecAddress;
     /** The action to approve */
-    action: ContractFunctionInteraction | FunctionCall;
+    action: ContractFunctionInteraction;
 };
 /**
  * Compute an authentication witness message hash from an intent and metadata
@@ -33,7 +39,7 @@ export type IntentAction = {
  * and use it for the authentication check.
  * Therefore, any allowed `innerHash` will therefore also have information around where it can be spent (version, chainId) and who can spend it (consumer).
  *
- * If using the `IntentAction`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ * If using the `CallIntent`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
  * The action is then used along with the `caller` to compute the `innerHash` and the consumer.
  *
  *
@@ -44,22 +50,68 @@ export type IntentAction = {
  * @param metadata - The metadata for the intent (chainId, version)
  * @returns The message hash for the action
  */
-export declare const computeAuthWitMessageHash: (intent: IntentInnerHash | IntentAction, metadata: IntentMetadata) => Promise<Fr>;
+export declare const computeAuthWitMessageHash: (intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, metadata: ChainInfo) => Promise<Fr>;
 /**
- * Computes the inner authwitness hash for a function call, for it to later be combined with the metadata
+ * Compute an authentication witness message hash from an intent and metadata. This is just
+ * a wrapper around computeAuthwitMessageHash that allows receiving an already computed messageHash as input
+ * @param messageHashOrIntent - The precomputed messageHash or intent to approve (consumer and innerHash or caller and call/action)
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the intent
+ */
+export declare function getMessageHashFromIntent(messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, chainInfo: ChainInfo): Promise<Fr>;
+/**
+ * Computes the inner authwitness hash for either a function call or an action, for it to later be combined with the metadata
  * required for the outer hash and eventually the full AuthWitness.
  * @param caller - Who is going to be calling the function
- * @param fnCall - The function call to compute the inner hash from
- * @returns The inner hash for the function call
- **/
-export declare const computeInnerAuthWitHashFromFunctionCall: (caller: AztecAddress, fnCall: FunctionCall) => Promise<Fr>;
-/**
- * Computes the inner authwitness hash for an action, that can either be a ContractFunctionInteraction
- * or an isolated FunctionCall. Since the former is just a wrapper around the latter, we can just extract
- * the first (and only) call from the ContractFunctionInteraction and use it to compute the inner hash.
- * @param caller - Who is going to be performing the action
- * @param action - The ContractFunctionInteraction or FunctionCall to compute the inner hash for
+ * @param action - The action to compute the inner hash from
  * @returns The inner hash for the action
  **/
 export declare const computeInnerAuthWitHashFromAction: (caller: AztecAddress, action: FunctionCall | ContractFunctionInteraction) => Promise<Fr>;
+/**
+ * Lookup the validity of an authwit in private and public contexts.
+ *
+ * Uses the chain id and version of the wallet.
+ *
+ * @param wallet - The wallet use to simulate and read the public data
+ * @param onBehalfOf - The address of the "approver"
+ * @param intent - The consumer and inner hash or the caller and action to lookup
+ * @param witness - The computed authentication witness to check
+ * @returns - A struct containing the validity of the authwit in private and public contexts.
+ */
+export declare function lookupValidity(wallet: Wallet, onBehalfOf: AztecAddress, intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, witness: AuthWitness): Promise<{
+    /** boolean flag indicating if the authwit is valid in private context */
+    isValidInPrivate: boolean;
+    /** boolean flag indicating if the authwit is valid in public context */
+    isValidInPublic: boolean;
+}>;
+/**
+ * Convenience class designed to wrap the very common interaction of setting a public authwit in the AuthRegistry contract
+ */
+export declare class SetPublicAuthwitContractInteraction extends ContractFunctionInteraction {
+    private from;
+    private constructor();
+    static create(wallet: Wallet, from: AztecAddress, messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, authorized: boolean): Promise<SetPublicAuthwitContractInteraction>;
+    /**
+     * Overrides the simulate method, adding the sender of the authwit (authorizer) as from
+     * and preventing misuse
+     * @param options - An optional object containing additional configuration for the transaction.
+     * @returns The result of the transaction as returned by the contract function.
+     */
+    simulate<T extends SimulateInteractionOptions>(options: Omit<T, 'from'>): Promise<SimulationReturn<T['includeMetadata']>>;
+    /**
+     * Overrides the profile method, adding the sender of the authwit (authorizer) as from
+     * and preventing misuse
+     * @param options - Same options as `simulate`, plus profiling method
+     * @returns An object containing the function return value and profile result.
+     */
+    profile(options?: Omit<ProfileInteractionOptions, 'from'>): Promise<TxProfileResult>;
+    /**
+     * Overrides the send method, adding the sender of the authwit (authorizer) as from
+     * and preventing misuse
+     * @param options - An optional object containing 'fee' options information
+     * @returns A SentTx instance for tracking the transaction status and information.
+     */
+    send(options?: Omit<SendInteractionOptions, 'from'>): SentTx;
+    private static getSetAuthorizedAbi;
+}
 //# sourceMappingURL=authwit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"authwit.d.ts","sourceRoot":"","sources":["../../src/utils/authwit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAE3F,8BAA8B;AAC9B,MAAM,MAAM,cAAc,GAAG;IAC3B,8BAA8B;IAC9B,OAAO,EAAE,EAAE,CAAC;IACZ,8BAA8B;IAC9B,OAAO,EAAE,EAAE,CAAC;CACb,CAAC;AAEF,gCAAgC;AAChC,MAAM,MAAM,eAAe,GAAG;IAC5B,qBAAqB;IACrB,QAAQ,EAAE,YAAY,CAAC;IACvB,4BAA4B;IAC5B,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC;CACxB,CAAC;AAEF,4BAA4B;AAC5B,MAAM,MAAM,YAAY,GAAG;IACzB,6BAA6B;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,4BAA4B;IAC5B,MAAM,EAAE,2BAA2B,GAAG,YAAY,CAAC;CACpD,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,yBAAyB,GAAU,QAAQ,eAAe,GAAG,YAAY,EAAE,UAAU,cAAc,gBAiB/G,CAAC;AAGF;;;;;;IAMI;AACJ,eAAO,MAAM,uCAAuC,GAAU,QAAQ,YAAY,EAAE,QAAQ,YAAY,gBAEvG,CAAC;AAEF;;;;;;;IAOI;AACJ,eAAO,MAAM,iCAAiC,GAC5C,QAAQ,YAAY,EACpB,QAAQ,YAAY,GAAG,2BAA2B,gBAInD,CAAC"}
+{"version":3,"file":"authwit.d.ts","sourceRoot":"","sources":["../../src/utils/authwit.ts"],"names":[],"mappings":"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"}

package/dest/utils/authwit.js

@@ -1,8 +1,12 @@
 import { Fr } from '@aztec/foundation/fields';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionType } from '@aztec/stdlib/abi';
 import { computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec/stdlib/auth-witness';
 import { computeVarArgsHash } from '@aztec/stdlib/hash';
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-// docs:start:authwit_computeAuthWitMessageHash
+/** Identifies ContractFunctionInteractionCallIntents */ function isContractFunctionIntractionCallIntent(messageHashOrIntent) {
+    return 'caller' in messageHashOrIntent && 'action' in messageHashOrIntent && messageHashOrIntent.action instanceof ContractFunctionInteraction;
+}
 /**
  * Compute an authentication witness message hash from an intent and metadata
  *
@@ -13,7 +17,7 @@ import { ContractFunctionInteraction } from '../contract/contract_function_inter
  * and use it for the authentication check.
  * Therefore, any allowed `innerHash` will therefore also have information around where it can be spent (version, chainId) and who can spend it (consumer).
  *
- * If using the `IntentAction`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ * If using the `CallIntent`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
  * The action is then used along with the `caller` to compute the `innerHash` and the consumer.
  *
  *
@@ -27,39 +31,230 @@ import { ContractFunctionInteraction } from '../contract/contract_function_inter
     const chainId = metadata.chainId;
     const version = metadata.version;
     if ('caller' in intent) {
-        const fnCall = intent.action instanceof ContractFunctionInteraction ? (await intent.action.request()).calls[0] : intent.action;
-        return computeOuterAuthWitHash(fnCall.to, chainId, version, await computeInnerAuthWitHashFromFunctionCall(intent.caller, fnCall));
+        const call = isContractFunctionIntractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+        return computeOuterAuthWitHash(call.to, chainId, version, await computeInnerAuthWitHashFromAction(intent.caller, call));
     } else {
         const inner = Buffer.isBuffer(intent.innerHash) ? Fr.fromBuffer(intent.innerHash) : intent.innerHash;
         return computeOuterAuthWitHash(intent.consumer, chainId, version, inner);
     }
 };
-// docs:end:authwit_computeAuthWitMessageHash
 /**
- * Computes the inner authwitness hash for a function call, for it to later be combined with the metadata
+ * Compute an authentication witness message hash from an intent and metadata. This is just
+ * a wrapper around computeAuthwitMessageHash that allows receiving an already computed messageHash as input
+ * @param messageHashOrIntent - The precomputed messageHash or intent to approve (consumer and innerHash or caller and call/action)
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the intent
+ */ export async function getMessageHashFromIntent(messageHashOrIntent, chainInfo) {
+    let messageHash;
+    const { chainId, version } = chainInfo;
+    if (Buffer.isBuffer(messageHashOrIntent)) {
+        messageHash = Fr.fromBuffer(messageHashOrIntent);
+    } else if (messageHashOrIntent instanceof Fr) {
+        messageHash = messageHashOrIntent;
+    } else {
+        messageHash = await computeAuthWitMessageHash(messageHashOrIntent, {
+            chainId,
+            version
+        });
+    }
+    return messageHash;
+}
+/**
+ * Computes the inner authwitness hash for either a function call or an action, for it to later be combined with the metadata
  * required for the outer hash and eventually the full AuthWitness.
  * @param caller - Who is going to be calling the function
- * @param fnCall - The function call to compute the inner hash from
- * @returns The inner hash for the function call
- **/ export const computeInnerAuthWitHashFromFunctionCall = async (caller, fnCall)=>{
-    return computeInnerAuthWitHash([
-        caller.toField(),
-        fnCall.selector.toField(),
-        await computeVarArgsHash(fnCall.args)
-    ]);
-};
-/**
- * Computes the inner authwitness hash for an action, that can either be a ContractFunctionInteraction
- * or an isolated FunctionCall. Since the former is just a wrapper around the latter, we can just extract
- * the first (and only) call from the ContractFunctionInteraction and use it to compute the inner hash.
- * @param caller - Who is going to be performing the action
- * @param action - The ContractFunctionInteraction or FunctionCall to compute the inner hash for
+ * @param action - The action to compute the inner hash from
  * @returns The inner hash for the action
  **/ export const computeInnerAuthWitHashFromAction = async (caller, action)=>{
-    action = action instanceof ContractFunctionInteraction ? (await action.request()).calls[0] : action;
+    const call = action instanceof ContractFunctionInteraction ? await action.getFunctionCall() : action;
     return computeInnerAuthWitHash([
         caller.toField(),
-        action.selector.toField(),
-        await computeVarArgsHash(action.args)
+        call.selector.toField(),
+        await computeVarArgsHash(call.args)
     ]);
 };
+/**
+ * Lookup the validity of an authwit in private and public contexts.
+ *
+ * Uses the chain id and version of the wallet.
+ *
+ * @param wallet - The wallet use to simulate and read the public data
+ * @param onBehalfOf - The address of the "approver"
+ * @param intent - The consumer and inner hash or the caller and action to lookup
+ * @param witness - The computed authentication witness to check
+ * @returns - A struct containing the validity of the authwit in private and public contexts.
+ */ export async function lookupValidity(wallet, onBehalfOf, intent, witness) {
+    let innerHash, consumer;
+    if ('caller' in intent) {
+        const call = isContractFunctionIntractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+        innerHash = await computeInnerAuthWitHashFromAction(intent.caller, call);
+        consumer = call.to;
+    } else if (Buffer.isBuffer(intent.innerHash)) {
+        innerHash = Fr.fromBuffer(intent.innerHash);
+        consumer = intent.consumer;
+    } else {
+        ({ innerHash, consumer } = intent);
+    }
+    const chainInfo = await wallet.getChainInfo();
+    const messageHash = await getMessageHashFromIntent(intent, chainInfo);
+    const results = {
+        isValidInPrivate: false,
+        isValidInPublic: false
+    };
+    // Check private
+    const lookupValidityAbi = {
+        name: 'lookup_validity',
+        isInitializer: false,
+        functionType: FunctionType.UTILITY,
+        isInternal: false,
+        isStatic: false,
+        parameters: [
+            {
+                name: 'message_hash',
+                type: {
+                    kind: 'field'
+                },
+                visibility: 'private'
+            }
+        ],
+        returnTypes: [
+            {
+                kind: 'boolean'
+            }
+        ],
+        errorTypes: {}
+    };
+    try {
+        results.isValidInPrivate = await new ContractFunctionInteraction(wallet, onBehalfOf, lookupValidityAbi, [
+            consumer,
+            innerHash
+        ]).simulate({
+            from: onBehalfOf,
+            authWitnesses: [
+                witness
+            ]
+        });
+    // TODO: Narrow down the error to make sure simulation failed due to an invalid authwit
+    // eslint-disable-next-line no-empty
+    } catch  {}
+    // check public
+    const isConsumableAbi = {
+        name: 'utility_is_consumable',
+        isInitializer: false,
+        functionType: FunctionType.UTILITY,
+        isInternal: false,
+        isStatic: false,
+        parameters: [
+            {
+                name: 'address',
+                type: {
+                    fields: [
+                        {
+                            name: 'inner',
+                            type: {
+                                kind: 'field'
+                            }
+                        }
+                    ],
+                    kind: 'struct',
+                    path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress'
+                },
+                visibility: 'private'
+            },
+            {
+                name: 'message_hash',
+                type: {
+                    kind: 'field'
+                },
+                visibility: 'private'
+            }
+        ],
+        returnTypes: [
+            {
+                kind: 'boolean'
+            }
+        ],
+        errorTypes: {}
+    };
+    results.isValidInPublic = await new ContractFunctionInteraction(wallet, ProtocolContractAddress.AuthRegistry, isConsumableAbi, [
+        onBehalfOf,
+        messageHash
+    ]).simulate({
+        from: onBehalfOf
+    });
+    return results;
+}
+/**
+ * Convenience class designed to wrap the very common interaction of setting a public authwit in the AuthRegistry contract
+ */ export class SetPublicAuthwitContractInteraction extends ContractFunctionInteraction {
+    from;
+    constructor(wallet, from, messageHash, authorized){
+        super(wallet, ProtocolContractAddress.AuthRegistry, SetPublicAuthwitContractInteraction.getSetAuthorizedAbi(), [
+            messageHash,
+            authorized
+        ]), this.from = from;
+    }
+    static async create(wallet, from, messageHashOrIntent, authorized) {
+        const chainInfo = await wallet.getChainInfo();
+        const messageHash = await getMessageHashFromIntent(messageHashOrIntent, chainInfo);
+        return new SetPublicAuthwitContractInteraction(wallet, from, messageHash, authorized);
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    simulate(options = {}) {
+        return super.simulate({
+            ...options,
+            from: this.from
+        });
+    }
+    /**
+   * Overrides the profile method, adding the sender of the authwit (authorizer) as from
+   * and preventing misuse
+   * @param options - Same options as `simulate`, plus profiling method
+   * @returns An object containing the function return value and profile result.
+   */ profile(options = {
+        profileMode: 'gates'
+    }) {
+        return super.profile({
+            ...options,
+            from: this.from
+        });
+    }
+    /**
+   * Overrides the send method, adding the sender of the authwit (authorizer) as from
+   * and preventing misuse
+   * @param options - An optional object containing 'fee' options information
+   * @returns A SentTx instance for tracking the transaction status and information.
+   */ send(options = {}) {
+        return super.send({
+            ...options,
+            from: this.from
+        });
+    }
+    static getSetAuthorizedAbi() {
+        return {
+            name: 'set_authorized',
+            isInitializer: false,
+            functionType: FunctionType.PUBLIC,
+            isInternal: true,
+            isStatic: false,
+            parameters: [
+                {
+                    name: 'message_hash',
+                    type: {
+                        kind: 'field'
+                    },
+                    visibility: 'private'
+                },
+                {
+                    name: 'authorize',
+                    type: {
+                        kind: 'boolean'
+                    },
+                    visibility: 'private'
+                }
+            ],
+            returnTypes: [],
+            errorTypes: {}
+        };
+    }
+}

package/dest/utils/cross_chain.d.ts

@@ -0,0 +1,24 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+/**
+ * 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 declare function waitForL1ToL2MessageReady(node: Pick<AztecNode, 'getBlockNumber' | 'getL1ToL2MessageBlock'>, l1ToL2MessageHash: Fr, opts: {
+    /** Timeout for the operation in seconds */ timeoutSeconds: number;
+    /** True if the message is meant to be consumed from a public function */ forPublicConsumption: boolean;
+}): Promise<boolean>;
+/**
+ * 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 opts - Options
+ * @returns True if the message is ready to be consumed, false otherwise
+ */
+export declare function isL1ToL2MessageReady(node: Pick<AztecNode, 'getBlockNumber' | 'getL1ToL2MessageBlock'>, l1ToL2MessageHash: Fr, opts: {
+    /** True if the message is meant to be consumed from a public function */ forPublicConsumption: boolean;
+    /** Cached synced block number for the message (will be fetched from PXE otherwise) */ messageBlockNumber?: number;
+}): Promise<boolean>;
+//# sourceMappingURL=cross_chain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cross_chain.d.ts","sourceRoot":"","sources":["../../src/utils/cross_chain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,gBAAgB,GAAG,uBAAuB,CAAC,EACjE,iBAAiB,EAAE,EAAE,EACrB,IAAI,EAAE;IACJ,2CAA2C,CAAC,cAAc,EAAE,MAAM,CAAC;IACnE,yEAAyE,CAAC,oBAAoB,EAAE,OAAO,CAAC;CACzG,oBASF;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,gBAAgB,GAAG,uBAAuB,CAAC,EACjE,iBAAiB,EAAE,EAAE,EACrB,IAAI,EAAE;IACJ,yEAAyE,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACxG,sFAAsF,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACpH,GACA,OAAO,CAAC,OAAO,CAAC,CAWlB"}

package/dest/utils/cross_chain.js

@@ -0,0 +1,30 @@
+import { retryUntil } from '@aztec/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 async function waitForL1ToL2MessageReady(node, l1ToL2MessageHash, opts) {
+    const messageBlockNumber = await node.getL1ToL2MessageBlock(l1ToL2MessageHash);
+    return retryUntil(()=>isL1ToL2MessageReady(node, l1ToL2MessageHash, {
+            ...opts,
+            messageBlockNumber
+        }), `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 opts - Options
+ * @returns True if the message is ready to be consumed, false otherwise
+ */ export async function isL1ToL2MessageReady(node, l1ToL2MessageHash, opts) {
+    const blockNumber = await node.getBlockNumber();
+    const messageBlockNumber = opts.messageBlockNumber ?? await node.getL1ToL2MessageBlock(l1ToL2MessageHash);
+    if (messageBlockNumber === undefined) {
+        return false;
+    }
+    // Note that public messages can be consumed 1 block earlier, since the sequencer will include the messages
+    // in the L1 to L2 message tree before executing the txs for the block. In private, however, we need to wait
+    // until the message is included so we can make use of the membership witness.
+    return opts.forPublicConsumption ? blockNumber + 1 >= messageBlockNumber : blockNumber >= messageBlockNumber;
+}

package/dest/utils/fee_juice.d.ts

@@ -1,7 +1,8 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 /**
  * Returns the owner's fee juice balance.
+ * Note: This is used only e2e_sandbox_example test. TODO: Consider nuking.
  */
-export declare function getFeeJuiceBalance(owner: AztecAddress, pxe: PXE): Promise<bigint>;
+export declare function getFeeJuiceBalance(owner: AztecAddress, node: AztecNode): Promise<bigint>;
 //# sourceMappingURL=fee_juice.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fee_juice.d.ts","sourceRoot":"","sources":["../../src/utils/fee_juice.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAGvF"}
+{"version":3,"file":"fee_juice.d.ts","sourceRoot":"","sources":["../../src/utils/fee_juice.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAG9F"}

package/dest/utils/fee_juice.js

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

package/dest/{fee → wallet}/account_entrypoint_meta_payment_method.d.ts

@@ -1,31 +1,34 @@
-import type { AuthWitnessProvider, FeePaymentMethod } from '@aztec/entrypoints/interfaces';
 import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { type ContractArtifact, type FunctionArtifact } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import type { Wallet } from './index.js';
 /**
- * Fee payment method that allows a contract to pay for its own deployment
+ * 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.
+ * 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 a fee payload.
+ * 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 AccountManager.ts#getSelfPaymentMethod
+ * This class can be seen in action in DeployAccountMethod.ts#getSelfPaymentMethod
  */
 export declare class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
+    private wallet;
     private artifact;
-    private authWitnessProvider;
     private feePaymentNameOrArtifact;
     private accountAddress;
-    private paymentMethod;
-    constructor(artifact: ContractArtifact, authWitnessProvider: AuthWitnessProvider, feePaymentNameOrArtifact: string | FunctionArtifact, accountAddress: AztecAddress, paymentMethod: FeePaymentMethod);
+    private paymentMethod?;
+    constructor(wallet: Wallet, artifact: ContractArtifact, feePaymentNameOrArtifact: string | FunctionArtifact, accountAddress: AztecAddress, paymentMethod?: FeePaymentMethod | undefined);
     getAsset(): Promise<AztecAddress>;
-    getExecutionPayload(gasSettings: GasSettings): Promise<ExecutionPayload>;
-    getFeePayer(gasSettings: GasSettings): Promise<AztecAddress>;
+    getExecutionPayload(): Promise<ExecutionPayload>;
+    getFeePayer(): Promise<AztecAddress>;
+    getGasSettings(): GasSettings | undefined;
 }
 //# sourceMappingURL=account_entrypoint_meta_payment_method.d.ts.map

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":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EAKtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kCAAmC,YAAW,gBAAgB;IAEvE,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,wBAAwB;IAChC,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,aAAa,CAAC;gBAJd,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,wBAAwB,EAAE,MAAM,GAAG,gBAAgB,EACnD,cAAc,EAAE,YAAY,EAC5B,aAAa,CAAC,EAAE,gBAAgB,YAAA;IAG1C,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC;IAI3B,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAmDtD,WAAW,IAAI,OAAO,CAAC,YAAY,CAAC;IAIpC,cAAc,IAAI,WAAW,GAAG,SAAS;CAG1C"}

package/dest/wallet/account_entrypoint_meta_payment_method.js

@@ -0,0 +1,76 @@
+import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
+import { EncodedAppEntrypointCalls } from '@aztec/entrypoints/encoding';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionCall, FunctionSelector, encodeArguments, getFunctionArtifactByName } from '@aztec/stdlib/abi';
+/**
+ * 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 {
+    wallet;
+    artifact;
+    feePaymentNameOrArtifact;
+    accountAddress;
+    paymentMethod;
+    constructor(wallet, artifact, feePaymentNameOrArtifact, accountAddress, paymentMethod){
+        this.wallet = wallet;
+        this.artifact = artifact;
+        this.feePaymentNameOrArtifact = feePaymentNameOrArtifact;
+        this.accountAddress = accountAddress;
+        this.paymentMethod = paymentMethod;
+    }
+    getAsset() {
+        return this.paymentMethod?.getAsset() ?? Promise.resolve(ProtocolContractAddress.FeeJuice);
+    }
+    async getExecutionPayload() {
+        // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
+        // It can be empty because the account might attempt to pay for the tx fee using its own
+        // FeeJuice balance
+        const { calls: feeCalls, authWitnesses: feeAuthwitnesses } = await this.paymentMethod?.getExecutionPayload() ?? ExecutionPayload.empty();
+        // Encode the calls for the fee
+        const feePayer = await this.paymentMethod?.getFeePayer() ?? this.accountAddress;
+        const isFeePayer = feePayer.equals(this.accountAddress);
+        let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
+        if (isFeePayer) {
+            // If the account is the fee payer, and the incoming fee payload has calls
+            // it can only be FeeJuicePaymentMethodWithClaim
+            // If the payload has no calls, it's paying using
+            // its own fee juice balance
+            accountFeePaymentMethodOptions = feeCalls.length === 0 ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
+        }
+        const feeEncodedCalls = await EncodedAppEntrypointCalls.create(feeCalls);
+        // Get the entrypoint args
+        const args = [
+            feeEncodedCalls,
+            accountFeePaymentMethodOptions,
+            false
+        ];
+        const feePaymentArtifact = typeof this.feePaymentNameOrArtifact === 'string' ? getFunctionArtifactByName(this.artifact, this.feePaymentNameOrArtifact) : this.feePaymentNameOrArtifact;
+        const entrypointCall = new FunctionCall(feePaymentArtifact.name, this.accountAddress, await FunctionSelector.fromNameAndParameters(feePaymentArtifact.name, feePaymentArtifact.parameters), feePaymentArtifact.functionType, false, feePaymentArtifact.isStatic, encodeArguments(feePaymentArtifact, args), feePaymentArtifact.returnTypes);
+        // Compute the authwitness required to verify the combined payload
+        const payloadAuthWitness = await this.wallet.createAuthWit(this.accountAddress, await feeEncodedCalls.hash());
+        return new ExecutionPayload([
+            entrypointCall
+        ], [
+            payloadAuthWitness,
+            ...feeAuthwitnesses
+        ], [], feeEncodedCalls.hashedArguments);
+    }
+    getFeePayer() {
+        return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.accountAddress);
+    }
+    getGasSettings() {
+        return this.paymentMethod?.getGasSettings();
+    }
+}