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

package/dest/contract/base_contract_interaction.js

@@ -1,149 +1,36 @@
 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 { toSendOptions } from './interaction_options.js';
 import { SentTx } from './sent_tx.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.
+   * This function throws an error if called on a utility 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.
+   * @param options - An object containing 'from' property representing
+   * the AztecAddress of the sender and optional fee configuration
    * @returns A SentTx instance for tracking the transaction status and information.
-   */ send(options = {}) {
+   */ 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
+        const sendTx = async ()=>{
+            const executionPayload = await this.request(options);
+            const sendOptions = await toSendOptions(options);
+            return this.wallet.sendTx(executionPayload, sendOptions);
         };
-    }
-    // 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;
+        return new SentTx(this.wallet, sendTx);
     }
 }

package/dest/contract/batch_call.d.ts

@@ -1,28 +1,27 @@
-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/entrypoints/payload';
+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
+     * 2. It supports `utility`, `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.
      */
-    simulate(options?: SimulateMethodOptions): Promise<any>;
+    simulate(options: SimulateInteractionOptions): Promise<any>;
+    protected getExecutionPayloads(): Promise<ExecutionPayload[]>;
 }
 //# sourceMappingURL=batch_call.d.ts.map

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":"AAAA,OAAO,EAAE,gBAAgB,EAA0B,MAAM,4BAA4B,CAAC;AAGtF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAEhC,MAAM,0BAA0B,CAAC;AAElC,qFAAqF;AACrF,qBAAa,SAAU,SAAQ,uBAAuB;IAGlD,SAAS,CAAC,YAAY,EAAE,CAAC,uBAAuB,GAAG,gBAAgB,CAAC,EAAE;gBADtE,MAAM,EAAE,MAAM,EACJ,YAAY,EAAE,CAAC,uBAAuB,GAAG,gBAAgB,CAAC,EAAE;IAKxE;;;;OAIG;IACU,OAAO,CAAC,OAAO,GAAE,yBAA8B,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAWxF;;;;;;;;OAQG;IACU,QAAQ,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,GAAG,CAAC;cA8ExD,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;CAGpE"}

package/dest/contract/batch_call.js

@@ -1,91 +1,91 @@
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
 import { FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
 import { BaseContractInteraction } from './base_contract_interaction.js';
+import { toSimulateOptions } from './interaction_options.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;
+    interactions;
+    constructor(wallet, interactions){
+        super(wallet), this.interactions = interactions;
     }
     /**
-   * 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
+   * 2. It supports `utility`, `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,
+   */ 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 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);
+        const utilityBatchPromise = utility.length > 0 ? this.wallet.batch(utility.map(([call])=>({
+                name: 'simulateUtility',
+                args: [
+                    call.name,
+                    call.args,
+                    call.to,
+                    options?.authWitnesses
+                ]
+            }))) : Promise.resolve([]);
+        const [utilityBatchResults, simulatedTx] = await Promise.all([
+            utilityBatchPromise,
+            indexedExecutionPayloads.length > 0 ? this.wallet.simulateTx(executionPayload, await toSimulateOptions(options)) : Promise.resolve()
         ]);
         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) : [];
+        utilityBatchResults.forEach((wrappedResult, utilityIndex)=>{
+            const [, originalIndex] = utility[utilityIndex];
+            results[originalIndex] = wrappedResult.result.result;
         });
+        if (simulatedTx) {
+            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.

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>;
     /**
-     * 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.

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;AAChE,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;IAK5G;;;;;;OAMG;WACW,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,eAAe,CAAC,EAAE,MAAM;IAKtG;;;;;;;;OAQG;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"}

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,30 +5,21 @@ 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;
-        }
+        const instance = await wallet.registerContract(address, artifact);
         return new Contract(instance, 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.
@@ -39,7 +29,8 @@ import { DeployMethod } from './deploy_method.js';
         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.

package/dest/contract/contract_base.d.ts

@@ -1,6 +1,6 @@
-import { type ContractArtifact, type ContractNote, type FieldLayout, FunctionSelector } from '@aztec/stdlib/abi';
+import { type ContractArtifact, type FieldLayout, FunctionSelector } from '@aztec/stdlib/abi';
 import { type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
 /**
  * Type representing a contract method that returns a ContractFunctionInteraction instance
@@ -18,12 +18,6 @@ export type ContractMethod = ((...args: any[]) => ContractFunctionInteraction) &
 export type ContractStorageLayout<T extends string> = {
     [K in T]: FieldLayout;
 };
-/**
- * Type representing the notes used in a contract.
- */
-export type ContractNotes<T extends string> = {
-    [K in T]: ContractNote;
-};
 /**
  * Abstract implementation of a contract extended by the Contract class and generated contract types.
  */
@@ -48,7 +42,7 @@ export declare class ContractBase {
     /** The wallet used for interacting with this contract. */
     wallet: Wallet);
     /** Address of the contract. */
-    get address(): import("@aztec/stdlib/aztec-address").AztecAddress;
+    get address(): import("../api/addresses.js").AztecAddress;
     /** Partial address of the contract. */
     get partialAddress(): Promise<import("@aztec/foundation/schemas").Fr>;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"contract_base.d.ts","sourceRoot":"","sources":["../../src/contract/contract_base.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,WAAW,EAEhB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,2BAA2B,EAAyB,MAAM,wBAAwB,CAAC;AAEjG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAEjF;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,2BAA2B,CAAC,GAAG;IAC/E;;OAEG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC3C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,MAAM,IAAI;KACnD,CAAC,IAAI,CAAC,GAAG,WAAW;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI;KAC3C,CAAC,IAAI,CAAC,GAAG,YAAY;CACvB,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAY;IAOrB,iDAAiD;aACjC,QAAQ,EAAE,2BAA2B;IACrD,yDAAyD;aACzC,QAAQ,EAAE,gBAAgB;IAC1C,0DAA0D;IACnD,MAAM,EAAE,MAAM;IAXvB;;OAEG;IACI,OAAO,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;KAAE,CAAM;IAExD,SAAS;IACP,iDAAiD;IACjC,QAAQ,EAAE,2BAA2B;IACrD,yDAAyD;IACzC,QAAQ,EAAE,gBAAgB;IAC1C,0DAA0D;IACnD,MAAM,EAAE,MAAM;IAmBvB,+BAA+B;IAC/B,IAAW,OAAO,uDAEjB;IAED,uCAAuC;IACvC,IAAW,cAAc,oDAExB;IAED;;;;OAIG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAGxC"}
+{"version":3,"file":"contract_base.d.ts","sourceRoot":"","sources":["../../src/contract/contract_base.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAEhB,gBAAgB,EAEjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,2BAA2B,EAAyB,MAAM,wBAAwB,CAAC;AAEjG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAEjF;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,2BAA2B,CAAC,GAAG;IAC/E;;OAEG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC3C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,MAAM,IAAI;KACnD,CAAC,IAAI,CAAC,GAAG,WAAW;CACtB,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAY;IAOrB,iDAAiD;aACjC,QAAQ,EAAE,2BAA2B;IACrD,yDAAyD;aACzC,QAAQ,EAAE,gBAAgB;IAC1C,0DAA0D;IACnD,MAAM,EAAE,MAAM;IAXvB;;OAEG;IACI,OAAO,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;KAAE,CAAM;IAExD,SAAS;IACP,iDAAiD;IACjC,QAAQ,EAAE,2BAA2B;IACrD,yDAAyD;IACzC,QAAQ,EAAE,gBAAgB;IAC1C,0DAA0D;IACnD,MAAM,EAAE,MAAM;IAmBvB,+BAA+B;IAC/B,IAAW,OAAO,+CAEjB;IAED,uCAAuC;IACvC,IAAW,cAAc,oDAExB;IAED;;;;OAIG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAGxC"}

package/dest/contract/contract_base.js

@@ -1,4 +1,4 @@
-import { FunctionSelector } from '@aztec/stdlib/abi';
+import { FunctionSelector, getAllFunctionAbis } from '@aztec/stdlib/abi';
 import { computePartialAddress } from '@aztec/stdlib/contract';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
 /**
@@ -15,7 +15,7 @@ import { ContractFunctionInteraction } from './contract_function_interaction.js'
         this.artifact = artifact;
         this.wallet = wallet;
         this.methods = {};
-        artifact.functions.forEach((f)=>{
+        getAllFunctionAbis(artifact).forEach((f)=>{
             const interactionFunction = (...args)=>{
                 return new ContractFunctionInteraction(this.wallet, this.instance.address, f, args);
             };