@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/utils/authwit.js

@@ -1,9 +1,12 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
-import { HashedValues } from '@aztec/stdlib/tx';
+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
  *
@@ -14,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.
  *
  *
@@ -28,47 +31,230 @@ import { ContractFunctionInteraction } from '../contract/contract_function_inter
     const chainId = metadata.chainId;
     const version = metadata.version;
     if ('caller' in intent) {
-        const action = intent.action instanceof ContractFunctionInteraction ? await intent.action.request() : intent.action;
-        return computeOuterAuthWitHash(action.to, chainId, version, await computeInnerAuthWitHashFromAction(intent.caller, action));
+        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
-export const computeInnerAuthWitHashFromAction = async (caller, action)=>computeInnerAuthWitHash([
+/**
+ * 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 action - The action to compute the inner hash from
+ * @returns The inner hash for the action
+ **/ export const computeInnerAuthWitHashFromAction = async (caller, action)=>{
+    const call = action instanceof ContractFunctionInteraction ? await action.getFunctionCall() : action;
+    return computeInnerAuthWitHash([
         caller.toField(),
-        action.selector.toField(),
-        (await HashedValues.fromValues(action.args)).hash
+        call.selector.toField(),
+        await computeVarArgsHash(call.args)
     ]);
-/**
- * Compute the inner hash for an authentication witness.
- * This is the "intent" of the message, before siloed with the consumer.
- * It is used as part of the `computeAuthWitMessageHash` but can also be used
- * in case the message is not a "call" to a function, but arbitrary data.
- * @param args - The arguments to hash
- * @returns The inner hash for the witness
- */ export const computeInnerAuthWitHash = (args)=>{
-    return poseidon2HashWithSeparator(args, GeneratorIndex.AUTHWIT_INNER);
 };
 /**
- * Compute the outer hash for an authentication witness.
- * This is the value siloed with its "consumer" and what the `on_behalf_of`
- * should be signing.
- * The consumer is who will be consuming the message, for token approvals it
- * is the token contract itself (because the token makes the call to check the approval).
- * It is used as part of the `computeAuthWitMessageHash` but can also be used
- * in case the message is not a "call" to a function, but arbitrary data.
- * @param consumer - The address that can "consume" the authwit
- * @param chainId - The chain id that can "consume" the authwit
- * @param version - The version that can "consume" the authwit
- * @param innerHash - The inner hash for the witness
- * @returns The outer hash for the witness
- */ const computeOuterAuthWitHash = (consumer, chainId, version, innerHash)=>{
-    return poseidon2HashWithSeparator([
-        consumer.toField(),
-        chainId,
-        version,
-        innerHash
-    ], GeneratorIndex.AUTHWIT_OUTER);
-};
+ * 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 '../api/interfaces/pxe.js';
+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;AAGhE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,0BAA0B,CAAC;AAEpD;;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/utils/field_compressed_string.d.ts.map

@@ -1 +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,UAAW,yBAAyB,KAAG,MAU5E,CAAC"}
+{"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,GAAI,OAAO,yBAAyB,KAAG,MAU5E,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/utils/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,eAAO,MAAM,WAAW,SAAgB,SAAS,WAAW,MAAM,kBAYjE,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/utils/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,eAAO,MAAM,WAAW,GAAU,MAAM,SAAS,EAAE,SAAS,MAAM,kBAYjE,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/utils/node.js

@@ -6,7 +6,7 @@ export const waitForNode = async (node, logger)=>{
             await node.getNodeInfo();
             logger?.verbose('Contacted Aztec node');
             return true;
-        } catch (error) {
+        } catch  {
             logger?.verbose('Failed to contact Aztec Node');
         }
         return undefined;

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

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

package/dest/utils/pub_key.js

@@ -4,6 +4,5 @@ import { Grumpkin } from '@aztec/foundation/crypto';
  * @param privateKey - The private key.
  * @returns The generated public key.
  */ export function generatePublicKey(privateKey) {
-    const grumpkin = new Grumpkin();
-    return grumpkin.mul(grumpkin.generator(), privateKey);
+    return Grumpkin.mul(Grumpkin.generator, privateKey);
 }

package/dest/wallet/account_entrypoint_meta_payment_method.d.ts

@@ -0,0 +1,34 @@
+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 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 wallet;
+    private artifact;
+    private feePaymentNameOrArtifact;
+    private accountAddress;
+    private paymentMethod?;
+    constructor(wallet: Wallet, artifact: ContractArtifact, feePaymentNameOrArtifact: string | FunctionArtifact, accountAddress: AztecAddress, paymentMethod?: FeePaymentMethod | undefined);
+    getAsset(): 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();
+    }
+}

package/dest/wallet/account_manager.d.ts

@@ -0,0 +1,69 @@
+import { Fr } from '@aztec/foundation/fields';
+import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { AccountContract } from '../account/account_contract.js';
+import { AccountWithSecretKey } from '../account/account_with_secret_key.js';
+import type { Salt } from '../account/index.js';
+import type { AccountInterface } from '../account/interface.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
+import type { Wallet } from './wallet.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 declare class AccountManager {
+    private wallet;
+    private secretKey;
+    private accountContract;
+    private instance;
+    /**
+     * Contract instantiation salt for the account contract
+     */
+    readonly salt: Salt;
+    private constructor();
+    static create(wallet: Wallet, secretKey: Fr, accountContract: AccountContract, salt?: Salt): Promise<AccountManager>;
+    protected getPublicKeys(): import("@aztec/stdlib/keys").PublicKeys;
+    protected getPublicKeysHash(): Fr | Promise<Fr>;
+    /**
+     * Returns the entrypoint for this account as defined by its account contract.
+     * @returns An entrypoint.
+     */
+    getAccountInterface(): Promise<AccountInterface>;
+    /**
+     * 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(): import("../api/addresses.js").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 a Wallet instance associated with this account. Use it to create Contract
+     * instances to be interacted with from this account.
+     * @returns A Wallet instance.
+     */
+    getAccount(): Promise<AccountWithSecretKey>;
+    /**
+     * 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=account_manager.d.ts.map

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,0BAA0B,CAAC;AAC9C,OAAO,EACL,eAAe,EACf,KAAK,2BAA2B,EAEjC,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;GAGG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ;IAChB;;OAEG;aACa,IAAI,EAAE,IAAI;IAR5B,OAAO;WAWM,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,eAAe,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,IAAI;IAoBhG,SAAS,CAAC,aAAa;IAIvB,SAAS,CAAC,iBAAiB;IAI3B;;;OAGG;IACU,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAM7D;;;;OAIG;IACI,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC;IAIrD;;OAEG;IACI,YAAY;IAInB,IAAI,OAAO,+CAEV;IAED;;;;OAIG;IACI,WAAW,IAAI,2BAA2B;IAIjD;;;;OAIG;IACU,UAAU,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAKxD;;;OAGG;IACH,kBAAkB,IAAI,eAAe;IAIrC;;;OAGG;IACU,eAAe,IAAI,OAAO,CAAC,mBAAmB,CAAC;IA0B5D;;OAEG;IACU,cAAc;CAG5B"}