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

package/dest/wallet/base_wallet.js

@@ -1,104 +1,227 @@
+import { GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT } from '@aztec/constants';
+import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
+import { mergeExecutionPayloads } from '@aztec/entrypoints/payload';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { computePartialAddress, getContractClassFromArtifact, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { Gas, GasSettings } from '@aztec/stdlib/gas';
+import { inspect } from 'util';
 /**
  * A base class for Wallet implementations
  */ export class BaseWallet {
     pxe;
-    scopes;
-    constructor(pxe, scopes){
+    aztecNode;
+    log;
+    baseFeePadding;
+    cancellableTransactions;
+    // Protected because we want to force wallets to instantiate their own PXE.
+    constructor(// TODO: We cannot type here pxe because we cannot import that package as that would result in a circular
+    // dependency. This will eventually get resolved by the introduction of @aztec/wallet-sdk package.
+    pxe, aztecNode){
         this.pxe = pxe;
-        this.scopes = scopes;
-    }
-    setScopes(scopes) {
-        this.scopes = scopes;
-    }
-    getScopes() {
-        return this.scopes;
-    }
-    getAddress() {
-        return this.getCompleteAddress().address;
-    }
-    storeCapsule(contract, storageSlot, capsule) {
-        return this.pxe.storeCapsule(contract, storageSlot, capsule);
-    }
-    registerAccount(secretKey, partialAddress) {
-        return this.pxe.registerAccount(secretKey, partialAddress);
-    }
-    getRegisteredAccounts() {
-        return this.pxe.getRegisteredAccounts();
-    }
-    registerSender(address) {
+        this.aztecNode = aztecNode;
+        this.log = createLogger('aztecjs:base_wallet');
+        this.baseFeePadding = 0.5;
+        this.cancellableTransactions = false;
+    }
+    /**
+   * Returns the list of aliased contacts associated with the wallet.
+   * This base implementation directly returns PXE's senders, but note that in general contacts are a superset of senders.
+   *  - Senders: Addresses we check during synching in case they sent us notes,
+   *  - Contacts: more general concept akin to a phone's contact list.
+   * @returns The aliased collection of AztecAddresses that form this wallet's address book
+   */ async getAddressBook() {
+        const senders = await this.pxe.getSenders();
+        return senders.map((sender)=>({
+                item: sender,
+                alias: ''
+            }));
+    }
+    async getChainInfo() {
+        const { l1ChainId, rollupVersion } = await this.aztecNode.getNodeInfo();
+        return {
+            chainId: new Fr(l1ChainId),
+            version: new Fr(rollupVersion)
+        };
+    }
+    async createTxExecutionRequestFromPayloadAndFee(executionPayload, from, feeOptions) {
+        const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+        const executionOptions = {
+            txNonce: Fr.random(),
+            cancellable: this.cancellableTransactions,
+            feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+        };
+        const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
+            feeExecutionPayload,
+            executionPayload
+        ]) : executionPayload;
+        const fromAccount = await this.getAccountFromAddress(from);
+        return fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, executionOptions);
+    }
+    async createAuthWit(from, messageHashOrIntent) {
+        const account = await this.getAccountFromAddress(from);
+        return account.createAuthWit(messageHashOrIntent);
+    }
+    async batch(methods) {
+        const results = [];
+        for (const method of methods){
+            const { name, args } = method;
+            // Type safety is guaranteed by the BatchedMethod type, which ensures that:
+            // 1. `name` is a valid batchable method name
+            // 2. `args` matches the parameter types of that specific method
+            // 3. The return type is correctly mapped in BatchResults<T>
+            // We use dynamic dispatch here for simplicity, but the types are enforced at the call site.
+            const fn = this[name];
+            const result = await fn.apply(this, args);
+            // Wrap result with method name for discriminated union deserialization
+            results.push({
+                name,
+                result
+            });
+        }
+        return results;
+    }
+    /**
+   * Returns default values for the transaction fee options
+   * if they were omitted by the user.
+   * @param from - The address where the transaction is being sent from
+   * @param userFeeOptions - User-provided fee options, which might be incomplete
+   * @returns - Populated fee options that can be used to create a transaction execution request
+   */ async getDefaultFeeOptions(from, userFeeOptions) {
+        const maxFeesPerGas = userFeeOptions?.gasSettings?.maxFeesPerGas ?? (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.baseFeePadding);
+        let accountFeePaymentMethodOptions;
+        // The transaction does not include a fee payment method, so we set the flag
+        // for the account to use its fee juice balance
+        if (!userFeeOptions?.embeddedPaymentMethodFeePayer) {
+            accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE;
+        } else {
+            // The transaction includes fee payment method, so we check if we are the fee payer for it
+            // (this can only happen if the embedded payment method is FeeJuiceWithClaim)
+            accountFeePaymentMethodOptions = from.equals(userFeeOptions.embeddedPaymentMethodFeePayer) ? AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM : AccountFeePaymentMethodOptions.EXTERNAL;
+        }
+        const gasSettings = GasSettings.default({
+            ...userFeeOptions?.gasSettings,
+            maxFeesPerGas
+        });
+        this.log.debug(`Using L2 gas settings`, gasSettings);
+        return {
+            gasSettings,
+            walletFeePaymentMethod: undefined,
+            accountFeePaymentMethodOptions
+        };
+    }
+    /**
+   * Returns unreasonably high gas limits in order to execute a simulation
+   * with the goal of estimating its gas cost. It will otherwise try to respect
+   * the user-specified fee options, filling the gaps with default values as needed.
+   * @param from - The address where the transaction is being sent from
+   * @param userFeeOptions - User-provided fee options to use as a basis for the fully populated `FeeOptions` type.
+   */ async getFeeOptionsForGasEstimation(from, userFeeOptions) {
+        const defaultFeeOptions = await this.getDefaultFeeOptions(from, userFeeOptions);
+        const { gasSettings: { maxFeesPerGas, maxPriorityFeesPerGas } } = defaultFeeOptions;
+        // Use unrealistically high gas limits for estimation to avoid running out of gas.
+        // They will be tuned down after the simulation.
+        const gasSettingsForEstimation = new GasSettings(new Gas(GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT), new Gas(GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT), maxFeesPerGas, maxPriorityFeesPerGas);
+        return {
+            ...defaultFeeOptions,
+            gasSettings: gasSettingsForEstimation
+        };
+    }
+    registerSender(address, _alias = '') {
         return this.pxe.registerSender(address);
     }
-    getSenders() {
-        return this.pxe.getSenders();
-    }
-    async removeSender(address) {
-        await this.pxe.removeSender(address);
-    }
-    registerContract(contract) {
-        return this.pxe.registerContract(contract);
-    }
-    registerContractClass(artifact) {
-        return this.pxe.registerContractClass(artifact);
-    }
-    updateContract(contractAddress, artifact) {
-        return this.pxe.updateContract(contractAddress, artifact);
-    }
-    getContracts() {
-        return this.pxe.getContracts();
-    }
-    proveTx(txRequest, privateExecutionResult) {
-        return this.pxe.proveTx(txRequest, privateExecutionResult);
-    }
-    simulateTx(txRequest, simulatePublic, msgSender, skipTxValidation, skipFeeEnforcement, profile) {
-        return this.pxe.simulateTx(txRequest, simulatePublic, msgSender, skipTxValidation, skipFeeEnforcement, profile, this.scopes);
-    }
-    sendTx(tx) {
-        return this.pxe.sendTx(tx);
-    }
-    getTxEffect(txHash) {
-        return this.pxe.getTxEffect(txHash);
-    }
-    getTxReceipt(txHash) {
-        return this.pxe.getTxReceipt(txHash);
-    }
-    getNotes(filter) {
-        return this.pxe.getNotes(filter);
-    }
-    getPublicStorageAt(contract, storageSlot) {
-        return this.pxe.getPublicStorageAt(contract, storageSlot);
-    }
-    getBlock(number) {
-        return this.pxe.getBlock(number);
-    }
-    getCurrentBaseFees() {
-        return this.pxe.getCurrentBaseFees();
-    }
-    simulateUnconstrained(functionName, args, to, from) {
-        return this.pxe.simulateUnconstrained(functionName, args, to, from);
-    }
-    getPublicLogs(filter) {
-        return this.pxe.getPublicLogs(filter);
-    }
-    getContractClassLogs(filter) {
-        return this.pxe.getContractClassLogs(filter);
-    }
-    getBlockNumber() {
-        return this.pxe.getBlockNumber();
-    }
-    getProvenBlockNumber() {
-        return this.pxe.getProvenBlockNumber();
-    }
-    getNodeInfo() {
-        return this.pxe.getNodeInfo();
-    }
-    addAuthWitness(authWitness) {
-        return this.pxe.addAuthWitness(authWitness);
-    }
-    getAuthWitness(messageHash) {
-        return this.pxe.getAuthWitness(messageHash);
-    }
-    getPXEInfo() {
-        return this.pxe.getPXEInfo();
+    async registerContract(instanceData, artifact, secretKey) {
+        /** Determines if the provided instance data is already a contract instance with an address. */ function isInstanceWithAddress(instanceData) {
+            return instanceData.address !== undefined;
+        }
+        /** Determines if the provided instance data is contract instantiation data */ function isContractInstantiationData(instanceData) {
+            return instanceData.salt !== undefined;
+        }
+        /** Determines if the provided instance data is already a contract */ function isContractInstanceAndArtifact(instanceData) {
+            return instanceData.instance !== undefined && instanceData.artifact !== undefined;
+        }
+        let instance;
+        if (isContractInstanceAndArtifact(instanceData)) {
+            instance = instanceData.instance;
+            await this.pxe.registerContract(instanceData);
+        } else if (isInstanceWithAddress(instanceData)) {
+            instance = instanceData;
+            await this.pxe.registerContract({
+                artifact,
+                instance
+            });
+        } else if (isContractInstantiationData(instanceData)) {
+            if (!artifact) {
+                throw new Error(`Contract artifact must be provided when registering a contract using instantiation data`);
+            }
+            instance = await getContractInstanceFromInstantiationParams(artifact, instanceData);
+            await this.pxe.registerContract({
+                artifact,
+                instance
+            });
+        } else {
+            if (!artifact) {
+                throw new Error(`Contract artifact must be provided when registering a contract using an address`);
+            }
+            const { contractInstance: maybeContractInstance } = await this.pxe.getContractMetadata(instanceData);
+            if (!maybeContractInstance) {
+                throw new Error(`Contract instance at ${instanceData.toString()} has not been registered in the wallet's PXE`);
+            }
+            instance = maybeContractInstance;
+            const thisContractClass = await getContractClassFromArtifact(artifact);
+            if (!thisContractClass.id.equals(instance.currentContractClassId)) {
+                // wallet holds an outdated version of this contract
+                await this.pxe.updateContract(instance.address, artifact);
+                instance.currentContractClassId = thisContractClass.id;
+            }
+        }
+        if (secretKey) {
+            await this.pxe.registerAccount(secretKey, await computePartialAddress(instance));
+        }
+        return instance;
+    }
+    async simulateTx(executionPayload, opts) {
+        const feeOptions = opts.fee?.estimateGas ? await this.getFeeOptionsForGasEstimation(opts.from, opts.fee) : await this.getDefaultFeeOptions(opts.from, opts.fee);
+        const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
+        return this.pxe.simulateTx(txRequest, true, opts?.skipTxValidation, opts?.skipFeeEnforcement ?? true);
+    }
+    async profileTx(executionPayload, opts) {
+        const fee = await this.getDefaultFeeOptions(opts.from, opts.fee);
+        const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, fee);
+        return this.pxe.profileTx(txRequest, opts.profileMode, opts.skipProofGeneration ?? true);
+    }
+    async sendTx(executionPayload, opts) {
+        const fee = await this.getDefaultFeeOptions(opts.from, opts.fee);
+        const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, fee);
+        const provenTx = await this.pxe.proveTx(txRequest);
+        const tx = await provenTx.toTx();
+        const txHash = tx.getTxHash();
+        if (await this.aztecNode.getTxEffect(txHash)) {
+            throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
+        }
+        this.log.debug(`Sending transaction ${txHash}`);
+        await this.aztecNode.sendTx(tx).catch((err)=>{
+            throw this.contextualizeError(err, inspect(tx));
+        });
+        this.log.info(`Sent transaction ${txHash}`);
+        return txHash;
+    }
+    contextualizeError(err, ...context) {
+        let contextStr = '';
+        if (context.length > 0) {
+            contextStr = `\nContext:\n${context.join('\n')}`;
+        }
+        if (err instanceof SimulationError) {
+            err.setAztecContext(contextStr);
+        } else {
+            this.log.error(err.name, err);
+            this.log.debug(contextStr);
+        }
+        return err;
+    }
+    simulateUtility(functionName, args, to, authwits, from) {
+        return this.pxe.simulateUtility(functionName, args, to, authwits, from);
     }
     getContractClassMetadata(id, includeArtifact = false) {
         return this.pxe.getContractClassMetadata(id, includeArtifact);
@@ -106,18 +229,10 @@
     getContractMetadata(address) {
         return this.pxe.getContractMetadata(address);
     }
-    getPrivateEvents(event, from, limit, vpks = [
-        this.getCompleteAddress().publicKeys.masterIncomingViewingPublicKey
-    ]) {
-        return this.pxe.getPrivateEvents(event, from, limit, vpks);
-    }
-    getPublicEvents(event, from, limit) {
-        return this.pxe.getPublicEvents(event, from, limit);
-    }
-    getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
-        return this.pxe.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
+    getTxReceipt(txHash) {
+        return this.aztecNode.getTxReceipt(txHash);
     }
-    getL2ToL1MembershipWitness(blockNumber, l2Tol1Message) {
-        return this.pxe.getL2ToL1MembershipWitness(blockNumber, l2Tol1Message);
+    getPrivateEvents(contractAddress, event, from, limit, recipients = []) {
+        return this.pxe.getPrivateEvents(contractAddress, event, from, limit, recipients);
     }
 }

package/dest/wallet/deploy_account_method.d.ts

@@ -0,0 +1,52 @@
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact, FunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PublicKeys } from '@aztec/stdlib/keys';
+import type { Contract } from '../contract/contract.js';
+import type { ContractBase } from '../contract/contract_base.js';
+import { DeployMethod, type DeployOptions, type RequestDeployOptions, type SimulateDeployOptions } from '../contract/deploy_method.js';
+import type { Wallet } from './index.js';
+/**
+ * The configuration options for the request method. Omits the contractAddressSalt, since
+ * for account contracts that is fixed in the constructor
+ */
+export type RequestDeployAccountOptions = Omit<RequestDeployOptions, 'contractAddressSalt'>;
+/**
+ * The configuration options for the send/prove methods. Omits:
+ * - The contractAddressSalt, since for account contracts that is fixed in the constructor.
+ * - UniversalDeployment flag, since account contracts are always deployed with it set to true
+ */
+export type DeployAccountOptions = Omit<DeployOptions, 'contractAddressSalt' | 'universalDeploy'>;
+/**
+ * The configuration options for the simulate method. Omits the contractAddressSalt, since
+ * for account contracts that is fixed in the constructor
+ */
+export type SimulateDeployAccountOptions = Omit<SimulateDeployOptions, 'contractAddressSalt'>;
+/**
+ * Modified version of the DeployMethod used to deploy account contracts. Supports deploying
+ * contracts that can pay for their own fee, plus some preconfigured options to avoid errors.
+ */
+export declare class DeployAccountMethod<TContract extends ContractBase = Contract> extends DeployMethod<TContract> {
+    private salt;
+    constructor(publicKeys: PublicKeys, wallet: Wallet, artifact: ContractArtifact, postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>, salt: Fr, args?: any[], constructorNameOrArtifact?: string | FunctionArtifact);
+    /**
+     * Returns a FeePaymentMethod that routes the original one provided as an argument
+     * through the account's entrypoint. This allows an account contract to pay
+     * for its own deployment and initialization.
+     *
+     * For more details on how the fee payment routing works see documentation of AccountEntrypointMetaPaymentMethod class.
+     *
+     * @param originalPaymentMethod - originalPaymentMethod The original payment method to be wrapped.
+     * @returns A FeePaymentMethod that routes the original one through the account's entrypoint (AccountEntrypointMetaPaymentMethod)
+     */
+    private getSelfFeePaymentMethod;
+    /**
+     * Returns the execution payload that allows this operation to happen on chain.
+     * @param opts - Configuration options.
+     * @returns The execution payload for this operation
+     */
+    request(opts?: RequestDeployAccountOptions): Promise<ExecutionPayload>;
+    convertDeployOptionsToRequestOptions(options: DeployOptions): RequestDeployOptions;
+}
+//# sourceMappingURL=deploy_account_method.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_account_method.d.ts","sourceRoot":"","sources":["../../src/wallet/deploy_account_method.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAA0B,MAAM,4BAA4B,CAAC;AACtF,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC3B,MAAM,8BAA8B,CAAC;AAGtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAAC,oBAAoB,EAAE,qBAAqB,CAAC,CAAC;AAE5F;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,EAAE,qBAAqB,GAAG,iBAAiB,CAAC,CAAC;AAElG;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG,IAAI,CAAC,qBAAqB,EAAE,qBAAqB,CAAC,CAAC;AAE9F;;;GAGG;AACH,qBAAa,mBAAmB,CAAC,SAAS,SAAS,YAAY,GAAG,QAAQ,CAAE,SAAQ,YAAY,CAAC,SAAS,CAAC;IAMvG,OAAO,CAAC,IAAI;gBAJZ,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,cAAc,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,EACrE,IAAI,EAAE,EAAE,EAChB,IAAI,GAAE,GAAG,EAAO,EAChB,yBAAyB,CAAC,EAAE,MAAM,GAAG,gBAAgB;IAKvD;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;;;OAIG;IACmB,OAAO,CAAC,IAAI,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgCnF,oCAAoC,CAAC,OAAO,EAAE,aAAa,GAAG,oBAAoB;CAU5F"}

package/dest/wallet/deploy_account_method.js

@@ -0,0 +1,77 @@
+import { mergeExecutionPayloads } from '@aztec/entrypoints/payload';
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { DeployMethod } from '../contract/deploy_method.js';
+import { AccountEntrypointMetaPaymentMethod } from './account_entrypoint_meta_payment_method.js';
+/**
+ * Modified version of the DeployMethod used to deploy account contracts. Supports deploying
+ * contracts that can pay for their own fee, plus some preconfigured options to avoid errors.
+ */ export class DeployAccountMethod extends DeployMethod {
+    salt;
+    constructor(publicKeys, wallet, artifact, postDeployCtor, salt, args = [], constructorNameOrArtifact){
+        super(publicKeys, wallet, artifact, postDeployCtor, args, constructorNameOrArtifact), this.salt = salt;
+    }
+    /**
+   * Returns a FeePaymentMethod that routes the original one provided as an argument
+   * through the account's entrypoint. This allows an account contract to pay
+   * for its own deployment and initialization.
+   *
+   * For more details on how the fee payment routing works see documentation of AccountEntrypointMetaPaymentMethod class.
+   *
+   * @param originalPaymentMethod - originalPaymentMethod The original payment method to be wrapped.
+   * @returns A FeePaymentMethod that routes the original one through the account's entrypoint (AccountEntrypointMetaPaymentMethod)
+   */ getSelfFeePaymentMethod(originalPaymentMethod) {
+        if (!this.address) {
+            throw new Error('Instance is not yet constructed. This is a bug!');
+        }
+        return new AccountEntrypointMetaPaymentMethod(this.wallet, this.artifact, 'entrypoint', this.address, originalPaymentMethod);
+    }
+    /**
+   * Returns the execution payload that allows this operation to happen on chain.
+   * @param opts - Configuration options.
+   * @returns The execution payload for this operation
+   */ async request(opts) {
+        const optionsWithDefaults = {
+            ...opts,
+            // Regardless of whom sends the transaction, account contracts
+            // are always deployed as universalDeployment: true
+            deployer: undefined,
+            contractAddressSalt: new Fr(this.salt),
+            skipClassPublication: opts?.skipClassPublication ?? true,
+            skipInstancePublication: opts?.skipInstancePublication ?? true,
+            skipInitialization: opts?.skipInitialization ?? false
+        };
+        // Override the fee to undefined, since we'll replace it
+        const deploymentExecutionPayload = await super.request({
+            ...optionsWithDefaults,
+            fee: undefined
+        });
+        const executionPayloads = [
+            deploymentExecutionPayload
+        ];
+        // If this is a self-deployment, manage the fee accordingly
+        if (opts?.deployer?.equals(AztecAddress.ZERO)) {
+            const feePaymentMethod = this.getSelfFeePaymentMethod(opts?.fee?.paymentMethod);
+            const feeExecutionPayload = await feePaymentMethod.getExecutionPayload();
+            // Notice they are reversed (fee payment usually goes first):
+            // this is because we need to construct the contract BEFORE it can pay for its own fee
+            executionPayloads.push(feeExecutionPayload);
+        } else {
+            const feeExecutionPayload = opts?.fee?.paymentMethod ? await opts.fee.paymentMethod.getExecutionPayload() : undefined;
+            if (feeExecutionPayload) {
+                executionPayloads.unshift(feeExecutionPayload);
+            }
+        }
+        return mergeExecutionPayloads(executionPayloads);
+    }
+    convertDeployOptionsToRequestOptions(options) {
+        return {
+            ...options,
+            // Deployer is handled in the request method and forcibly set to undefined,
+            // since our account contracts are created with universalDeployment: true
+            // We need to forward it though, because depending on the deployer we have to assemble
+            // The fee payment method one way or another
+            deployer: options.from
+        };
+    }
+}

package/dest/wallet/index.d.ts

@@ -1,17 +1,4 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { AccountContract } from '../account/contract.js';
-import { AccountWallet } from './account_wallet.js';
-export * from '../account/wallet.js';
-export * from './account_wallet.js';
-export * from './account_wallet_with_private_key.js';
-export * from './signerless_wallet.js';
-/**
- * Gets a wallet for an already registered account.
- * @param pxe - PXE Service instance.
- * @param address - Address for the account.
- * @param accountContract - Account contract implementation.
- * @returns A wallet for this account that can be used to interact with a contract instance.
- */
-export declare function getWallet(pxe: PXE, address: AztecAddress, accountContract: AccountContract): Promise<AccountWallet>;
+export * from './wallet.js';
+export * from './base_wallet.js';
+export * from './account_manager.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wallet/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,YAAY,EACrB,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,aAAa,CAAC,CAUxB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wallet/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}

package/dest/wallet/index.js

@@ -1,20 +1,3 @@
-import { AccountWallet } from './account_wallet.js';
-export * from '../account/wallet.js';
-export * from './account_wallet.js';
-export * from './account_wallet_with_private_key.js';
-export * from './signerless_wallet.js';
-/**
- * Gets a wallet for an already registered account.
- * @param pxe - PXE Service instance.
- * @param address - Address for the account.
- * @param accountContract - Account contract implementation.
- * @returns A wallet for this account that can be used to interact with a contract instance.
- */ export async function getWallet(pxe, address, accountContract) {
-    const completeAddress = (await pxe.getRegisteredAccounts()).find((completeAddress)=>completeAddress.address.equals(address));
-    if (!completeAddress) {
-        throw new Error(`Account ${address} not found`);
-    }
-    const nodeInfo = await pxe.getNodeInfo();
-    const entrypoint = accountContract.getInterface(completeAddress, nodeInfo);
-    return new AccountWallet(pxe, entrypoint);
-}
+export * from './wallet.js';
+export * from './base_wallet.js';
+export * from './account_manager.js';