@aztec/aztec.js 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/dest/contract/base_contract_interaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base_contract_interaction.d.ts","sourceRoot":"","sources":["../../src/contract/base_contract_interaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAErF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG3E,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,2CAA2C;IAC3C,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,kKAAkK;IAClK,KAAK,CAAC,EAAE,EAAE,CAAC;IACX,qIAAqI;IACrI,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,8BAAsB,uBAAuB;IAK/B,SAAS,CAAC,MAAM,EAAE,MAAM;IAJpC,SAAS,CAAC,GAAG,yCAAgD;IAE7D,OAAO,CAAC,QAAQ,CAAiB;gBAEX,MAAM,EAAE,MAAM;IAEpC;;;;OAIG;aACa,MAAM,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAEhF;;;;;;OAMG;cACa,aAAa,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC;IAOxF;;;;OAIG;IACU,KAAK,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAOtE;;;;;;;;OAQG;IACI,IAAI,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM;IAUpD;;;;;OAKG;IACU,WAAW,CACtB,IAAI,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,aAAa,GAAG,sBAAsB,CAAC,GACrE,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,mBAAmB,CAAC,CAAC;IAiBhE;;;OAGG;cACa,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;IAU1F;;;;;OAKG;cACa,aAAa,CAC3B,OAAO,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,GAAG;QAAmC,GAAG,CAAC,EAAE,cAAc,CAAA;KAAE,GACrG,OAAO,CAAC,UAAU,CAAC;IA+BtB;;;OAGG;IACI,UAAU,CAAC,OAAO,EAAE,OAAO;IAIlC;;;OAGG;IACI,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE;IAItC;;OAEG;IACI,WAAW;CAGnB"}
+{"version":3,"file":"base_contract_interaction.d.ts","sourceRoot":"","sources":["../../src/contract/base_contract_interaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,iCAAiC,EACtC,KAAK,UAAU,EAEhB,MAAM,0BAA0B,CAAC;AAElC;;;GAGG;AACH,8BAAsB,uBAAuB;IAIzC,SAAS,CAAC,MAAM,EAAE,MAAM;IACxB,SAAS,CAAC,aAAa,EAAE,WAAW,EAAE;IACtC,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE;IAL/B,SAAS,CAAC,GAAG,yCAAgD;IAE7D,YACY,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,WAAW,EAAO,EACjC,QAAQ,GAAE,OAAO,EAAO,EAChC;IAEJ;;;;;OAKG;IACH,SAAgB,OAAO,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAGxF;;;;;;OAMG;IAEI,IAAI,CAAC,OAAO,GAAG,SAAS,EAAE,OAAO,EAAE,iCAAiC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAGxF,IAAI,CAAC,OAAO,GAAG,SAAS,EAAE,CAAC,SAAS,sBAAsB,GAAG,SAAS,EAC3E,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;CAWpC"}

package/dest/contract/base_contract_interaction.js

@@ -1,149 +1,24 @@
 import { createLogger } from '@aztec/foundation/log';
-import { GasSettings } from '@aztec/stdlib/gas';
-import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
-import { getGasLimits } from './get_gas_limits.js';
-import { ProvenTx } from './proven_tx.js';
-import { SentTx } from './sent_tx.js';
+import { toSendOptions } from './interaction_options.js';
 /**
  * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
  * Implements the sequence create/simulate/send.
  */ export class BaseContractInteraction {
     wallet;
-    log;
+    authWitnesses;
     capsules;
-    constructor(wallet){
+    log;
+    constructor(wallet, authWitnesses = [], capsules = []){
         this.wallet = wallet;
+        this.authWitnesses = authWitnesses;
+        this.capsules = capsules;
         this.log = createLogger('aztecjs:contract_interaction');
-        this.capsules = [];
-    }
-    /**
-   * Creates a transaction execution request, simulates and proves it. Differs from .prove in
-   * that its result does not include the wallet nor the composed tx object, but only the proving result.
-   * This object can then be used to either create a ProvenTx ready to be sent, or directly send the transaction.
-   * @param options - optional arguments to be used in the creation of the transaction
-   * @returns The proving result.
-   */ async proveInternal(options = {}) {
-        const txRequest = await this.create(options);
-        const txSimulationResult = await this.wallet.simulateTx(txRequest, !options.skipPublicSimulation, undefined, true);
-        return await this.wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
     }
-    // docs:start:prove
-    /**
-   * Proves a transaction execution request and returns a tx object ready to be sent.
-   * @param options - optional arguments to be used in the creation of the transaction
-   * @returns The resulting transaction
-   */ async prove(options = {}) {
-        // docs:end:prove
-        const txProvingResult = await this.proveInternal(options);
-        return new ProvenTx(this.wallet, txProvingResult.toTx());
-    }
-    // docs:start:send
-    /**
-   * Sends a transaction to the contract function with the specified options.
-   * This function throws an error if called on an unconstrained function.
-   * It creates and signs the transaction if necessary, and returns a SentTx instance,
-   * which can be used to track the transaction status, receipt, and events.
-   * @param options - An optional object containing 'from' property representing
-   * the AztecAddress of the sender. If not provided, the default address is used.
-   * @returns A SentTx instance for tracking the transaction status and information.
-   */ send(options = {}) {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async send(options) {
         // docs:end:send
-        const promise = (async ()=>{
-            const txProvingResult = await this.proveInternal(options);
-            return this.wallet.sendTx(txProvingResult.toTx());
-        })();
-        return new SentTx(this.wallet, promise);
-    }
-    // docs:start:estimateGas
-    /**
-   * Estimates gas for a given tx request and returns gas limits for it.
-   * @param opts - Options.
-   * @param pad - Percentage to pad the suggested gas limits by, if empty, defaults to 10%.
-   * @returns Gas limits.
-   */ async estimateGas(opts) {
-        // docs:end:estimateGas
-        const txRequest = await this.create({
-            ...opts,
-            fee: {
-                ...opts?.fee,
-                estimateGas: false
-            }
-        });
-        const simulationResult = await this.wallet.simulateTx(txRequest, true, undefined /* msgSender */ , undefined /* skipTxValidation */ , true);
-        const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(simulationResult, opts?.fee?.estimatedGasPadding);
-        return {
-            gasLimits,
-            teardownGasLimits
-        };
-    }
-    /**
-   * Returns default fee options based on the user opts without running a simulation for gas estimation.
-   * @param fee - User-provided fee options.
-   */ async getDefaultFeeOptions(fee) {
-        const maxFeesPerGas = fee?.gasSettings?.maxFeesPerGas ?? (await this.wallet.getCurrentBaseFees()).mul(1 + (fee?.baseFeePadding ?? 0.5));
-        const paymentMethod = fee?.paymentMethod ?? new FeeJuicePaymentMethod(this.wallet.getAddress());
-        const gasSettings = GasSettings.default({
-            ...fee?.gasSettings,
-            maxFeesPerGas
-        });
-        this.log.debug(`Using L2 gas settings`, gasSettings);
-        return {
-            gasSettings,
-            paymentMethod
-        };
-    }
-    // docs:start:getFeeOptions
-    /**
-   * Return fee options based on the user opts, estimating tx gas if needed.
-   * @param request - Request to execute for this interaction.
-   * @param pad - Percentage to pad the suggested gas limits by, as decimal (e.g., 0.10 for 10%).
-   * @returns Fee options for the actual transaction.
-   */ async getFeeOptions(request) {
-        // docs:end:getFeeOptions
-        const defaultFeeOptions = await this.getDefaultFeeOptions(request.fee);
-        const paymentMethod = defaultFeeOptions.paymentMethod;
-        const maxFeesPerGas = defaultFeeOptions.gasSettings.maxFeesPerGas;
-        const maxPriorityFeesPerGas = defaultFeeOptions.gasSettings.maxPriorityFeesPerGas;
-        let gasSettings = defaultFeeOptions.gasSettings;
-        if (request.fee?.estimateGas) {
-            const feeForEstimation = {
-                paymentMethod,
-                gasSettings
-            };
-            const txRequest = await this.wallet.createTxExecutionRequest({
-                ...request,
-                fee: feeForEstimation
-            });
-            const simulationResult = await this.wallet.simulateTx(txRequest, true, undefined /* msgSender */ , undefined /* skipTxValidation */ , true);
-            const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(simulationResult, request.fee?.estimatedGasPadding);
-            gasSettings = GasSettings.from({
-                maxFeesPerGas,
-                maxPriorityFeesPerGas,
-                gasLimits,
-                teardownGasLimits
-            });
-            this.log.verbose(`Estimated gas limits for tx: DA=${gasLimits.daGas} L2=${gasLimits.l2Gas} teardownDA=${teardownGasLimits.daGas} teardownL2=${teardownGasLimits.l2Gas}`);
-        }
-        return {
-            gasSettings,
-            paymentMethod
-        };
-    }
-    /**
-   * Add data passed to the oracle calls during this contract interaction.
-   * @param capsule - Data passed to oracle calls.
-   */ addCapsule(capsule) {
-        this.capsules.push(capsule);
-    }
-    /**
-   * Add data passed to the oracle calls during this contract interaction.
-   * @param capsules - Data passed to oracle calls.
-   */ addCapsules(capsules) {
-        this.capsules.push(...capsules);
-    }
-    /**
-   * Return all capsules added for this function interaction.
-   */ getCapsules() {
-        return this.capsules;
+        const executionPayload = await this.request(options);
+        const sendOptions = toSendOptions(options);
+        return await this.wallet.sendTx(executionPayload, sendOptions);
     }
 }

package/dest/contract/batch_call.d.ts

@@ -1,28 +1,26 @@
-import { type FunctionCall } from '@aztec/stdlib/abi';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
-import type { Wallet } from '../account/index.js';
-import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
-import type { SimulateMethodOptions } from './contract_function_interaction.js';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
+import type { Wallet } from '../wallet/wallet.js';
+import { BaseContractInteraction } from './base_contract_interaction.js';
+import { type RequestInteractionOptions, type SimulateInteractionOptions } from './interaction_options.js';
 /** A batch of function calls to be sent as a single transaction through a wallet. */
 export declare class BatchCall extends BaseContractInteraction {
-    protected calls: FunctionCall[];
-    constructor(wallet: Wallet, calls: FunctionCall[]);
+    protected interactions: (BaseContractInteraction | ExecutionPayload)[];
+    constructor(wallet: Wallet, interactions: (BaseContractInteraction | ExecutionPayload)[]);
     /**
-     * Create a transaction execution request that represents this batch, encoded and authenticated by the
-     * user's wallet, ready to be simulated.
-     * @param opts - An optional object containing additional configuration for the transaction.
-     * @returns A Promise that resolves to a transaction instance.
+     * Returns an execution request that represents this operation.
+     * @param options - An optional object containing additional configuration for the request generation.
+     * @returns An execution payload wrapped in promise.
      */
-    create(opts?: SendMethodOptions): Promise<TxExecutionRequest>;
+    request(options?: RequestInteractionOptions): Promise<ExecutionPayload>;
     /**
-     * Simulate a transaction and get its return values
-     * Differs from prove in a few important ways:
-     * 1. It returns the values of the function execution
-     * 2. It supports `unconstrained`, `private` and `public` functions
-     *
-     * @param options - An optional object containing additional configuration for the transaction.
-     * @returns The result of the transaction as returned by the contract function.
+     * Simulates the batch, supporting private, public and utility functions. Although this is a single
+     * interaction with the wallet, private and public functions will be grouped into a single ExecutionPayload
+     * that the wallet will simulate as a single transaction. Utility function calls will simply be executed
+     * one by one.
+     * @param options - An optional object containing additional configuration for the interaction.
+     * @returns The results of all the interactions that make up the batch
      */
-    simulate(options?: SimulateMethodOptions): Promise<any>;
+    simulate(options: SimulateInteractionOptions): Promise<any>;
+    protected getExecutionPayloads(): Promise<ExecutionPayload[]>;
 }
-//# sourceMappingURL=batch_call.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmF0Y2hfY2FsbC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2JhdGNoX2NhbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLGdCQUFnQixFQUlqQixNQUFNLGtCQUFrQixDQUFDO0FBRTFCLE9BQU8sS0FBSyxFQUFpQixNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RSxPQUFPLEVBQ0wsS0FBSyx5QkFBeUIsRUFDOUIsS0FBSywwQkFBMEIsRUFFaEMsTUFBTSwwQkFBMEIsQ0FBQztBQUVsQyxxRkFBcUY7QUFFckYscUJBQWEsU0FBVSxTQUFRLHVCQUF1QjtJQUdsRCxTQUFTLENBQUMsWUFBWSxFQUFFLENBQUMsdUJBQXVCLEdBQUcsZ0JBQWdCLENBQUMsRUFBRTtJQUZ4RSxZQUNFLE1BQU0sRUFBRSxNQUFNLEVBQ0osWUFBWSxFQUFFLENBQUMsdUJBQXVCLEdBQUcsZ0JBQWdCLENBQUMsRUFBRSxFQUd2RTtJQUdEOzs7O09BSUc7SUFDVSxPQUFPLENBQUMsT0FBTyxHQUFFLHlCQUE4QixHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQVN2RjtJQUVEOzs7Ozs7O09BT0c7SUFDVSxRQUFRLENBQUMsT0FBTyxFQUFFLDBCQUEwQixHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0F5RnZFO0lBRUQsVUFBZ0Isb0JBQW9CLElBQUksT0FBTyxDQUFDLGdCQUFnQixFQUFFLENBQUMsQ0FFbEU7Q0FDRiJ9

package/dest/contract/batch_call.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch_call.d.ts","sourceRoot":"","sources":["../../src/contract/batch_call.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAA+B,MAAM,mBAAmB,CAAC;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACjG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,qFAAqF;AACrF,qBAAa,SAAU,SAAQ,uBAAuB;IACxB,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE;gBAA/C,MAAM,EAAE,MAAM,EAAY,KAAK,EAAE,YAAY,EAAE;IAI3D;;;;;OAKG;IACU,MAAM,CAAC,IAAI,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAO1E;;;;;;;;OAQG;IACU,QAAQ,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,GAAG,CAAC;CA2DzE"}
+{"version":3,"file":"batch_call.d.ts","sourceRoot":"","sources":["../../src/contract/batch_call.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAIjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAiB,MAAM,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAEhC,MAAM,0BAA0B,CAAC;AAElC,qFAAqF;AAErF,qBAAa,SAAU,SAAQ,uBAAuB;IAGlD,SAAS,CAAC,YAAY,EAAE,CAAC,uBAAuB,GAAG,gBAAgB,CAAC,EAAE;IAFxE,YACE,MAAM,EAAE,MAAM,EACJ,YAAY,EAAE,CAAC,uBAAuB,GAAG,gBAAgB,CAAC,EAAE,EAGvE;IAGD;;;;OAIG;IACU,OAAO,CAAC,OAAO,GAAE,yBAA8B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CASvF;IAED;;;;;;;OAOG;IACU,QAAQ,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,GAAG,CAAC,CAyFvE;IAED,UAAgB,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAElE;CACF"}

package/dest/contract/batch_call.js

@@ -1,91 +1,111 @@
 import { FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 import { BaseContractInteraction } from './base_contract_interaction.js';
-/** A batch of function calls to be sent as a single transaction through a wallet. */ export class BatchCall extends BaseContractInteraction {
-    calls;
-    constructor(wallet, calls){
-        super(wallet), this.calls = calls;
+import { toSimulateOptions } from './interaction_options.js';
+/** A batch of function calls to be sent as a single transaction through a wallet. */ // docs:start:batch_call_class
+export class BatchCall extends BaseContractInteraction {
+    interactions;
+    constructor(wallet, interactions){
+        super(wallet), this.interactions = interactions;
     }
+    // docs:end:batch_call_class
     /**
-   * Create a transaction execution request that represents this batch, encoded and authenticated by the
-   * user's wallet, ready to be simulated.
-   * @param opts - An optional object containing additional configuration for the transaction.
-   * @returns A Promise that resolves to a transaction instance.
-   */ async create(opts) {
-        const calls = this.calls;
-        const capsules = this.getCapsules();
-        const fee = await this.getFeeOptions({
-            calls,
-            capsules,
-            ...opts
-        });
-        return await this.wallet.createTxExecutionRequest({
-            calls,
-            capsules,
-            ...opts,
-            fee
-        });
+   * Returns an execution request that represents this operation.
+   * @param options - An optional object containing additional configuration for the request generation.
+   * @returns An execution payload wrapped in promise.
+   */ async request(options = {}) {
+        const requests = await this.getExecutionPayloads();
+        const feeExecutionPayload = options.fee?.paymentMethod ? await options.fee.paymentMethod.getExecutionPayload() : undefined;
+        const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
+            feeExecutionPayload,
+            ...requests
+        ]) : mergeExecutionPayloads([
+            ...requests
+        ]);
+        return finalExecutionPayload;
     }
     /**
-   * Simulate a transaction and get its return values
-   * Differs from prove in a few important ways:
-   * 1. It returns the values of the function execution
-   * 2. It supports `unconstrained`, `private` and `public` functions
-   *
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns The result of the transaction as returned by the contract function.
-   */ async simulate(options = {}) {
-        const { indexedCalls, unconstrained } = this.calls.reduce((acc, current, index)=>{
-            if (current.type === FunctionType.UNCONSTRAINED) {
-                acc.unconstrained.push([
-                    current,
+   * Simulates the batch, supporting private, public and utility functions. Although this is a single
+   * interaction with the wallet, private and public functions will be grouped into a single ExecutionPayload
+   * that the wallet will simulate as a single transaction. Utility function calls will simply be executed
+   * one by one.
+   * @param options - An optional object containing additional configuration for the interaction.
+   * @returns The results of all the interactions that make up the batch
+   */ async simulate(options) {
+        const { indexedExecutionPayloads, utility } = (await this.getExecutionPayloads()).reduce((acc, current, index)=>{
+            const call = current.calls[0];
+            if (call.type === FunctionType.UTILITY) {
+                acc.utility.push([
+                    call,
                     index
                 ]);
             } else {
-                acc.indexedCalls.push([
+                acc.indexedExecutionPayloads.push([
                     current,
                     index,
-                    current.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++
+                    call.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++
                 ]);
             }
             return acc;
         }, {
-            indexedCalls: [],
-            unconstrained: [],
+            indexedExecutionPayloads: [],
+            utility: [],
             publicIndex: 0,
             privateIndex: 0
         });
-        const calls = indexedCalls.map(([call])=>call);
-        const capsules = this.getCapsules();
-        const fee = await this.getFeeOptions({
-            calls,
-            capsules,
-            ...options
-        });
-        const txRequest = await this.wallet.createTxExecutionRequest({
-            calls,
-            capsules,
-            ...options,
-            fee
-        });
-        const unconstrainedCalls = unconstrained.map(async ([call, index])=>[
-                await this.wallet.simulateUnconstrained(call.name, call.args, call.to, options?.from),
-                index
-            ]);
-        const [unconstrainedResults, simulatedTx] = await Promise.all([
-            Promise.all(unconstrainedCalls),
-            this.wallet.simulateTx(txRequest, true, options?.from, options?.skipTxValidation)
-        ]);
+        const batchRequests = [];
+        // Add utility calls to batch
+        for (const [call] of utility){
+            batchRequests.push({
+                name: 'simulateUtility',
+                args: [
+                    call,
+                    options?.authWitnesses
+                ]
+            });
+        }
+        // Add tx simulation to batch if there are any private/public calls
+        if (indexedExecutionPayloads.length > 0) {
+            const payloads = indexedExecutionPayloads.map(([request])=>request);
+            const combinedPayload = mergeExecutionPayloads(payloads);
+            const executionPayload = new ExecutionPayload(combinedPayload.calls, combinedPayload.authWitnesses.concat(options.authWitnesses ?? []), combinedPayload.capsules.concat(options.capsules ?? []), combinedPayload.extraHashedArgs);
+            batchRequests.push({
+                name: 'simulateTx',
+                args: [
+                    executionPayload,
+                    toSimulateOptions(options)
+                ]
+            });
+        }
+        const batchResults = batchRequests.length > 0 ? await this.wallet.batch(batchRequests) : [];
         const results = [];
-        unconstrainedResults.forEach(([result, index])=>{
-            results[index] = result;
-        });
-        indexedCalls.forEach(([call, callIndex, resultIndex])=>{
-            // As account entrypoints are private, for private functions we retrieve the return values from the first nested call
-            // since we're interested in the first set of values AFTER the account entrypoint
-            // For public functions we retrieve the first values directly from the public output.
-            const rawReturnValues = call.type == FunctionType.PRIVATE ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
-            results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
-        });
+        // Process utility results (they come first in batch results)
+        for(let i = 0; i < utility.length; i++){
+            const [call, resultIndex] = utility[i];
+            const wrappedResult = batchResults[i];
+            if (wrappedResult.name === 'simulateUtility') {
+                const rawReturnValues = wrappedResult.result.result;
+                results[resultIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+            }
+        }
+        // Process tx simulation result (it comes last if present)
+        if (indexedExecutionPayloads.length > 0) {
+            const txResultWrapper = batchResults[utility.length];
+            if (txResultWrapper.name === 'simulateTx') {
+                const simulatedTx = txResultWrapper.result;
+                indexedExecutionPayloads.forEach(([request, callIndex, resultIndex])=>{
+                    const call = request.calls[0];
+                    // As account entrypoints are private, for private functions we retrieve the return values from the first nested call
+                    // since we're interested in the first set of values AFTER the account entrypoint
+                    // For public functions we retrieve the first values directly from the public output.
+                    const rawReturnValues = call.type == FunctionType.PRIVATE ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
+                    results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+                });
+            }
+        }
         return results;
     }
+    async getExecutionPayloads() {
+        return await Promise.all(this.interactions.map((i)=>i instanceof ExecutionPayload ? i : i.request()));
+    }
 }

package/dest/contract/checker.d.ts

@@ -1,4 +1,4 @@
-import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { type ContractArtifact } from '@aztec/stdlib/abi';
 /**
  * Validates the given ContractArtifact object by checking its functions and their parameters.
  * Ensures that the ABI has at least one function, a constructor, valid bytecode, and correct parameter types.
@@ -8,4 +8,4 @@ import type { ContractArtifact } from '@aztec/stdlib/abi';
  * @returns A boolean value indicating whether the artifact is valid or not.
  */
 export declare function abiChecker(artifact: ContractArtifact): boolean;
-//# sourceMappingURL=checker.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2NoZWNrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUdMLEtBQUssZ0JBQWdCLEVBR3RCLE1BQU0sbUJBQW1CLENBQUM7QUFRM0I7Ozs7Ozs7R0FPRztBQUNILHdCQUFnQixVQUFVLENBQUMsUUFBUSxFQUFFLGdCQUFnQixXQTZCcEQifQ==

package/dest/contract/checker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../../src/contract/checker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAc,MAAM,mBAAmB,CAAC;AAQ1F;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,gBAAgB,WA8BpD"}
+{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../../src/contract/checker.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EAGtB,MAAM,mBAAmB,CAAC;AAQ3B;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,gBAAgB,WA6BpD"}

package/dest/contract/checker.js

@@ -1,3 +1,4 @@
+import { getDefaultInitializer } from '@aztec/stdlib/abi';
 /**
  * Validates the given ContractArtifact object by checking its functions and their parameters.
  * Ensures that the ABI has at least one function, a constructor, valid bytecode, and correct parameter types.
@@ -24,8 +25,7 @@
             abiParameterTypeChecker(param.type);
         });
     });
-    // TODO: implement a better check for constructor (right now only checks if it has it or not)
-    if (!artifact.functions.find((func)=>func.name === 'constructor')) {
+    if (!getDefaultInitializer(artifact)) {
         throw new Error('ABI has no constructor');
     }
     return true;

package/dest/contract/contract.d.ts

@@ -1,27 +1,27 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PublicKeys } from '@aztec/stdlib/keys';
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractBase } from './contract_base.js';
 import { DeployMethod } from './deploy_method.js';
 /**
  * The Contract class represents a contract and provides utility methods for interacting with it.
  * It enables the creation of ContractFunctionInteraction instances for each function in the contract's ABI,
  * allowing users to call or send transactions to these functions. Additionally, the Contract class can be used
- * to attach the contract instance to a deployed contract on-chain through the PXE, which facilitates
+ * to attach the contract instance to a deployed contract onchain through the PXE, which facilitates
  * interaction with Aztec's privacy protocol.
  */
 export declare class Contract extends ContractBase {
     /**
-     * Creates a contract instance.
-     * @param address - The deployed contract's address.
+     * Gets a contract instance.
+     * @param address - The address of the contract instance.
      * @param artifact - Build artifact of the contract.
      * @param wallet - The wallet to use when interacting with the contract.
      * @returns A promise that resolves to a new Contract instance.
      */
-    static at(address: AztecAddress, artifact: ContractArtifact, wallet: Wallet): Promise<Contract>;
+    static at(address: AztecAddress, artifact: ContractArtifact, wallet: Wallet): Contract;
     /**
-     * Creates a tx to deploy a new instance of a contract.
+     * Creates a tx to deploy (initialize and/or publish) a new instance of a contract.
      * @param wallet - The wallet for executing the deployment.
      * @param artifact - Build artifact of the contract to deploy
      * @param args - Arguments for the constructor.
@@ -29,7 +29,8 @@ export declare class Contract extends ContractBase {
      */
     static deploy(wallet: Wallet, artifact: ContractArtifact, args: any[], constructorName?: string): DeployMethod<Contract>;
     /**
-     * Creates a tx to deploy a new instance of a contract using the specified public keys hash to derive the address.
+     * Creates a tx to deploy (initialize and/or publish) a new instance of a contract
+     * using the specified public keys hash to derive the address.
      * @param publicKeys - Hash of public keys to use for deriving the address.
      * @param wallet - The wallet for executing the deployment.
      * @param artifact - Build artifact of the contract.
@@ -38,4 +39,4 @@ export declare class Contract extends ContractBase {
      */
     static deployWithPublicKeys(publicKeys: PublicKeys, wallet: Wallet, artifact: ContractArtifact, args: any[], constructorName?: string): DeployMethod<Contract>;
 }
-//# sourceMappingURL=contract.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb250cmFjdC9jb250cmFjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzFELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRWhFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVoRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWxEOzs7Ozs7R0FNRztBQUNILHFCQUFhLFFBQVMsU0FBUSxZQUFZO0lBQ3hDOzs7Ozs7T0FNRztJQUNILE9BQWMsRUFBRSxDQUFDLE9BQU8sRUFBRSxZQUFZLEVBQUUsUUFBUSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxNQUFNLEdBQUcsUUFBUSxDQUU1RjtJQUVEOzs7Ozs7T0FNRztJQUNILE9BQWMsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLGdCQUFnQixFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRSxlQUFlLENBQUMsRUFBRSxNQUFNLDBCQUlyRztJQUVEOzs7Ozs7OztPQVFHO0lBQ0gsT0FBYyxvQkFBb0IsQ0FDaEMsVUFBVSxFQUFFLFVBQVUsRUFDdEIsTUFBTSxFQUFFLE1BQU0sRUFDZCxRQUFRLEVBQUUsZ0JBQWdCLEVBQzFCLElBQUksRUFBRSxHQUFHLEVBQUUsRUFDWCxlQUFlLENBQUMsRUFBRSxNQUFNLDBCQUt6QjtDQUNGIn0=

package/dest/contract/contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/contract/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,YAAY;IACxC;;;;;;OAMG;WACiB,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAc5G;;;;;;OAMG;WACW,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,eAAe,CAAC,EAAE,MAAM;IAKtG;;;;;;;OAOG;WACW,oBAAoB,CAChC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,GAAG,EAAE,EACX,eAAe,CAAC,EAAE,MAAM;CAK3B"}
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/contract/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,YAAY;IACxC;;;;;;OAMG;IACH,OAAc,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAE5F;IAED;;;;;;OAMG;IACH,OAAc,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,eAAe,CAAC,EAAE,MAAM,0BAIrG;IAED;;;;;;;;OAQG;IACH,OAAc,oBAAoB,CAChC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,GAAG,EAAE,EACX,eAAe,CAAC,EAAE,MAAM,0BAKzB;CACF"}

package/dest/contract/contract.js

@@ -1,4 +1,3 @@
-import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { PublicKeys } from '@aztec/stdlib/keys';
 import { ContractBase } from './contract_base.js';
 import { DeployMethod } from './deploy_method.js';
@@ -6,47 +5,38 @@ import { DeployMethod } from './deploy_method.js';
  * The Contract class represents a contract and provides utility methods for interacting with it.
  * It enables the creation of ContractFunctionInteraction instances for each function in the contract's ABI,
  * allowing users to call or send transactions to these functions. Additionally, the Contract class can be used
- * to attach the contract instance to a deployed contract on-chain through the PXE, which facilitates
+ * to attach the contract instance to a deployed contract onchain through the PXE, which facilitates
  * interaction with Aztec's privacy protocol.
  */ export class Contract extends ContractBase {
     /**
-   * Creates a contract instance.
-   * @param address - The deployed contract's address.
+   * Gets a contract instance.
+   * @param address - The address of the contract instance.
    * @param artifact - Build artifact of the contract.
    * @param wallet - The wallet to use when interacting with the contract.
    * @returns A promise that resolves to a new Contract instance.
-   */ static async at(address, artifact, wallet) {
-        const instance = (await wallet.getContractMetadata(address)).contractInstance;
-        if (instance === undefined) {
-            throw new Error(`Contract instance at ${address.toString()} has not been registered in the wallet's PXE`);
-        }
-        const thisContractClass = await getContractClassFromArtifact(artifact);
-        if (!thisContractClass.id.equals(instance.currentContractClassId)) {
-            // wallet holds an outdated version of this contract
-            await wallet.updateContract(address, artifact);
-            instance.currentContractClassId = thisContractClass.id;
-        }
-        return new Contract(instance, artifact, wallet);
+   */ static at(address, artifact, wallet) {
+        return new Contract(address, artifact, wallet);
     }
     /**
-   * Creates a tx to deploy a new instance of a contract.
+   * Creates a tx to deploy (initialize and/or publish) a new instance of a contract.
    * @param wallet - The wallet for executing the deployment.
    * @param artifact - Build artifact of the contract to deploy
    * @param args - Arguments for the constructor.
    * @param constructorName - The name of the constructor function to call.
    */ static deploy(wallet, artifact, args, constructorName) {
-        const postDeployCtor = (address, wallet)=>Contract.at(address, artifact, wallet);
+        const postDeployCtor = (instance, wallet)=>Contract.at(instance.address, artifact, wallet);
         return new DeployMethod(PublicKeys.default(), wallet, artifact, postDeployCtor, args, constructorName);
     }
     /**
-   * Creates a tx to deploy a new instance of a contract using the specified public keys hash to derive the address.
+   * Creates a tx to deploy (initialize and/or publish) a new instance of a contract
+   * using the specified public keys hash to derive the address.
    * @param publicKeys - Hash of public keys to use for deriving the address.
    * @param wallet - The wallet for executing the deployment.
    * @param artifact - Build artifact of the contract.
    * @param args - Arguments for the constructor.
    * @param constructorName - The name of the constructor function to call.
    */ static deployWithPublicKeys(publicKeys, wallet, artifact, args, constructorName) {
-        const postDeployCtor = (address, wallet)=>Contract.at(address, artifact, wallet);
+        const postDeployCtor = (instance, wallet)=>Contract.at(instance.address, artifact, wallet);
         return new DeployMethod(publicKeys, wallet, artifact, postDeployCtor, args, constructorName);
     }
 }