@aztec/aztec.js 0.0.0-test.0

package/dest/contract/deploy_sent_tx.js

@@ -0,0 +1,43 @@
+import { createLogger } from '@aztec/foundation/log';
+import { SentTx } from './sent_tx.js';
+/**
+ * A contract deployment transaction sent to the network, extending SentTx with methods to create a contract instance.
+ */ export class DeploySentTx extends SentTx {
+    postDeployCtor;
+    instanceGetter;
+    log;
+    constructor(pxeOrWallet, txHashPromise, postDeployCtor, /** A getter for the deployed contract instance */ instanceGetter){
+        super(pxeOrWallet, txHashPromise), this.postDeployCtor = postDeployCtor, this.instanceGetter = instanceGetter, this.log = createLogger('aztecjs:deploy_sent_tx');
+    }
+    /**
+   * Awaits for the tx to be mined and returns the contract instance. Throws if tx is not mined.
+   * @param opts - Options for configuring the waiting for the tx to be mined.
+   * @returns The deployed contract instance.
+   */ async deployed(opts) {
+        const receipt = await this.wait(opts);
+        const instance = await this.instanceGetter();
+        this.log.info(`Contract ${instance.address.toString()} successfully deployed.`);
+        return receipt.contract;
+    }
+    /**
+   * Awaits for the tx to be mined and returns the receipt along with a contract instance. Throws if tx is not mined.
+   * @param opts - Options for configuring the waiting for the tx to be mined.
+   * @returns The transaction receipt with the deployed contract instance.
+   */ async wait(opts) {
+        const receipt = await super.wait(opts);
+        const contract = await this.getContractObject(opts?.wallet);
+        return {
+            ...receipt,
+            contract
+        };
+    }
+    async getContractObject(wallet) {
+        const isWallet = (pxeOrWallet)=>!!pxeOrWallet.createTxExecutionRequest;
+        const contractWallet = wallet ?? (isWallet(this.pxeOrNode) && this.pxeOrNode);
+        if (!contractWallet) {
+            throw new Error(`A wallet is required for creating a contract instance`);
+        }
+        const instance = await this.instanceGetter();
+        return this.postDeployCtor(instance.address, contractWallet);
+    }
+}

package/dest/contract/get_gas_limits.d.ts

@@ -0,0 +1,18 @@
+import type { Gas } from '@aztec/stdlib/gas';
+import type { TxSimulationResult } from '@aztec/stdlib/tx';
+/**
+ * Returns suggested total and teardown gas limits for a simulated tx.
+ * Note that public gas usage is only accounted for if the publicOutput is present.
+ * @param pad - Percentage to pad the suggested gas limits by, (as decimal, e.g., 0.10 for 10%).
+ */
+export declare function getGasLimits(simulationResult: TxSimulationResult, pad?: number): {
+    /**
+     * Total gas used across private and public
+     */
+    totalGas: Gas;
+    /**
+     * Teardown gas used
+     */
+    teardownGas: Gas;
+};
+//# sourceMappingURL=get_gas_limits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get_gas_limits.d.ts","sourceRoot":"","sources":["../../src/contract/get_gas_limits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,gBAAgB,EAAE,kBAAkB,EACpC,GAAG,SAAM,GACR;IACD;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC;IACd;;OAEG;IACH,WAAW,EAAE,GAAG,CAAC;CAClB,CAKA"}

package/dest/contract/get_gas_limits.js

@@ -0,0 +1,10 @@
+/**
+ * Returns suggested total and teardown gas limits for a simulated tx.
+ * Note that public gas usage is only accounted for if the publicOutput is present.
+ * @param pad - Percentage to pad the suggested gas limits by, (as decimal, e.g., 0.10 for 10%).
+ */ export function getGasLimits(simulationResult, pad = 0.1) {
+    return {
+        totalGas: simulationResult.gasUsed.totalGas.mul(1 + pad),
+        teardownGas: simulationResult.gasUsed.teardownGas.mul(1 + pad)
+    };
+}

package/dest/contract/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The `contract` module provides utilities for deploying and interacting with contracts, based on a
+ * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
+ * `Wallet` instance, and to the {@link https://docs.aztec.network/developers/guides/smart_contracts/how_to_compile_contract | Compiling contracts}
+ * section of the documentation for how to generate an artifact out of your Noir source code.
+ *
+ * The {@link Contract} class is the main class in this module, and provides static methods for deploying
+ * a contract or interacting with an already deployed one. The `methods` property of the contract instance
+ * provides access to private, public, and simulate methods, that can be invoked in a transaction via `send()`,
+ * or can be queried via `simulate()`.
+ *
+ * ```ts
+ * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send().deployed();
+ * console.log(`Contract deployed at ${contract.address}`);
+ * ```
+ *
+ * ```ts
+ * const contract = await Contract.at(address, MyContractArtifact, wallet);
+ * await contract.methods.mint(1000, owner).send().wait();
+ * console.log(`Total supply is now ${await contract.methods.totalSupply().simulate()}`);
+ * ```
+ *
+ * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
+ * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
+ * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
+ * or obtaining the `request` for aggregating into a {@link BatchCall}.
+ *
+ * The result of `send`ing a transaction is a {@link SentTx} object, from which you can get the
+ * transaction hash, or simply `wait` until the transaction is mined and the local PXE Service
+ * has synchronized its changes.
+ *
+ * @remarks If you are using typescript, consider using the
+ * {@link https://docs.aztec.network/developers/guides/smart_contracts/how_to_compile_contract#typescript-interfaces | autogenerated type-safe interfaces}
+ * for interacting with your contracts.
+ *
+ * @packageDocumentation
+ */
+export { Contract } from './contract.js';
+export { ContractFunctionInteraction, type ProfileResult, type SendMethodOptions, } from './contract_function_interaction.js';
+export { DefaultWaitOpts, SentTx, type WaitOpts } from './sent_tx.js';
+export { ContractBase, type ContractMethod, type ContractNotes, type ContractStorageLayout } from './contract_base.js';
+export { BatchCall } from './batch_call.js';
+export { type DeployOptions, DeployMethod } from './deploy_method.js';
+export { DeploySentTx } from './deploy_sent_tx.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,2BAA2B,EAC3B,KAAK,aAAa,EAClB,KAAK,iBAAiB,GACvB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AACvH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,KAAK,aAAa,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/dest/contract/index.js

@@ -0,0 +1,43 @@
+/**
+ * The `contract` module provides utilities for deploying and interacting with contracts, based on a
+ * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
+ * `Wallet` instance, and to the {@link https://docs.aztec.network/developers/guides/smart_contracts/how_to_compile_contract | Compiling contracts}
+ * section of the documentation for how to generate an artifact out of your Noir source code.
+ *
+ * The {@link Contract} class is the main class in this module, and provides static methods for deploying
+ * a contract or interacting with an already deployed one. The `methods` property of the contract instance
+ * provides access to private, public, and simulate methods, that can be invoked in a transaction via `send()`,
+ * or can be queried via `simulate()`.
+ *
+ * ```ts
+ * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send().deployed();
+ * console.log(`Contract deployed at ${contract.address}`);
+ * ```
+ *
+ * ```ts
+ * const contract = await Contract.at(address, MyContractArtifact, wallet);
+ * await contract.methods.mint(1000, owner).send().wait();
+ * console.log(`Total supply is now ${await contract.methods.totalSupply().simulate()}`);
+ * ```
+ *
+ * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
+ * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
+ * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
+ * or obtaining the `request` for aggregating into a {@link BatchCall}.
+ *
+ * The result of `send`ing a transaction is a {@link SentTx} object, from which you can get the
+ * transaction hash, or simply `wait` until the transaction is mined and the local PXE Service
+ * has synchronized its changes.
+ *
+ * @remarks If you are using typescript, consider using the
+ * {@link https://docs.aztec.network/developers/guides/smart_contracts/how_to_compile_contract#typescript-interfaces | autogenerated type-safe interfaces}
+ * for interacting with your contracts.
+ *
+ * @packageDocumentation
+ */ export { Contract } from './contract.js';
+export { ContractFunctionInteraction } from './contract_function_interaction.js';
+export { DefaultWaitOpts, SentTx } from './sent_tx.js';
+export { ContractBase } from './contract_base.js';
+export { BatchCall } from './batch_call.js';
+export { DeployMethod } from './deploy_method.js';
+export { DeploySentTx } from './deploy_sent_tx.js';

package/dest/contract/protocol_contracts.d.ts

@@ -0,0 +1,9 @@
+import type { Wallet } from '../wallet/index.js';
+import { UnsafeContract } from './unsafe_contract.js';
+/** Returns a Contract wrapper for the class registerer. */
+export declare function getRegistererContract(wallet: Wallet): Promise<UnsafeContract>;
+/** Returns a Contract wrapper for the instance deployer. */
+export declare function getDeployerContract(wallet: Wallet): Promise<UnsafeContract>;
+/** Returns a Contract wrapper for the fee juice */
+export declare function getFeeJuice(wallet: Wallet): Promise<UnsafeContract>;
+//# sourceMappingURL=protocol_contracts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocol_contracts.d.ts","sourceRoot":"","sources":["../../src/contract/protocol_contracts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,2DAA2D;AAC3D,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,MAAM,2BAQzD;AAED,4DAA4D;AAC5D,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,2BAOvD;AAED,mDAAmD;AACnD,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,2BAO/C"}

package/dest/contract/protocol_contracts.js

@@ -0,0 +1,26 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { UnsafeContract } from './unsafe_contract.js';
+/** Returns a Contract wrapper for the class registerer. */ export async function getRegistererContract(wallet) {
+    const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractClassRegisterer);
+    if (!contractInstance) {
+        throw new Error("ContractClassRegisterer is not registered in this wallet's instance");
+    }
+    const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
+    return new UnsafeContract(contractInstance, artifact, wallet);
+}
+/** Returns a Contract wrapper for the instance deployer. */ export async function getDeployerContract(wallet) {
+    const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractInstanceDeployer);
+    if (!contractInstance) {
+        throw new Error("ContractInstanceDeployer is not registered in this wallet's instance");
+    }
+    const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
+    return new UnsafeContract(contractInstance, artifact, wallet);
+}
+/** Returns a Contract wrapper for the fee juice */ export async function getFeeJuice(wallet) {
+    const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.FeeJuice);
+    if (!contractInstance) {
+        throw new Error("FeeJuice is not registered in this wallet's instance");
+    }
+    const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
+    return new UnsafeContract(contractInstance, artifact, wallet);
+}

package/dest/contract/proven_tx.d.ts

@@ -0,0 +1,17 @@
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { Tx } from '@aztec/stdlib/tx';
+import type { Wallet } from '../account/index.js';
+import { SentTx } from './sent_tx.js';
+/**
+ * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract interaction.
+ */
+export declare class ProvenTx extends Tx {
+    protected wallet: PXE | Wallet;
+    constructor(wallet: PXE | Wallet, tx: Tx);
+    protected getPlainDataTx(): Tx;
+    /**
+     * Sends the transaction to the network via the provided wallet.
+     */
+    send(): SentTx;
+}
+//# sourceMappingURL=proven_tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proven_tx.d.ts","sourceRoot":"","sources":["../../src/contract/proven_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAEtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;GAEG;AACH,qBAAa,QAAS,SAAQ,EAAE;IAClB,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM;gBAApB,MAAM,EAAE,GAAG,GAAG,MAAM,EAAE,EAAE,EAAE,EAAE;IAWlD,SAAS,CAAC,cAAc,IAAI,EAAE;IAU9B;;OAEG;IACI,IAAI,IAAI,MAAM;CAOtB"}

package/dest/contract/proven_tx.js

@@ -0,0 +1,22 @@
+import { Tx } from '@aztec/stdlib/tx';
+import { SentTx } from './sent_tx.js';
+/**
+ * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract interaction.
+ */ export class ProvenTx extends Tx {
+    wallet;
+    constructor(wallet, tx){
+        super(tx.data, tx.clientIvcProof, tx.contractClassLogs, tx.enqueuedPublicFunctionCalls, tx.publicTeardownFunctionCall), this.wallet = wallet;
+    }
+    // Clone the TX data to get a serializable object.
+    getPlainDataTx() {
+        return new Tx(this.data, this.clientIvcProof, this.contractClassLogs, this.enqueuedPublicFunctionCalls, this.publicTeardownFunctionCall);
+    }
+    /**
+   * Sends the transaction to the network via the provided wallet.
+   */ send() {
+        const promise = (()=>{
+            return this.wallet.sendTx(this.getPlainDataTx());
+        })();
+        return new SentTx(this.wallet, promise);
+    }
+}

package/dest/contract/sent_tx.d.ts

@@ -0,0 +1,61 @@
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AztecNode, GetPublicLogsResponse, PXE } from '@aztec/stdlib/interfaces/client';
+import { type TxHash, type TxReceipt } from '@aztec/stdlib/tx';
+/** Options related to waiting for a tx. */
+export type WaitOpts = {
+    /** The amount of time to ignore TxStatus.DROPPED receipts (in seconds) due to the presumption that it is being propagated by the p2p network. Defaults to 5. */
+    ignoreDroppedReceiptsFor?: number;
+    /** The maximum time (in seconds) to wait for the transaction to be mined. Defaults to 60. */
+    timeout?: number;
+    /** The maximum time (in seconds) to wait for the transaction to be proven. Defaults to 600. */
+    provenTimeout?: number;
+    /** The time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
+    interval?: number;
+    /** Whether to wait for the tx to be proven. */
+    proven?: boolean;
+    /** Whether to include information useful for debugging/testing in the receipt. */
+    debug?: boolean;
+    /** Whether to accept a revert as a status code for the tx when waiting for it. If false, will throw if the tx reverts. */
+    dontThrowOnRevert?: boolean;
+};
+export declare const DefaultWaitOpts: WaitOpts;
+/**
+ * The SentTx class represents a sent transaction through the PXE (or directly to a node) providing methods to fetch
+ * its hash, receipt, and mining status.
+ */
+export declare class SentTx {
+    protected pxeOrNode: PXE | AztecNode;
+    protected txHashPromise: Promise<TxHash>;
+    constructor(pxeOrNode: PXE | AztecNode, txHashPromise: Promise<TxHash>);
+    /**
+     * Retrieves the transaction hash of the SentTx instance.
+     * The function internally awaits for the 'txHashPromise' to resolve, and then returns the resolved transaction hash.
+     *
+     * @returns A promise that resolves to the transaction hash of the SentTx instance.
+     * TODO(#7717): Don't throw here.
+     */
+    getTxHash(): Promise<TxHash>;
+    /**
+     * Retrieve the transaction receipt associated with the current SentTx instance.
+     * The function fetches the transaction hash using 'getTxHash' and then queries
+     * the PXE to get the corresponding transaction receipt.
+     *
+     * @returns A promise that resolves to a TxReceipt object representing the fetched transaction receipt.
+     */
+    getReceipt(): Promise<TxReceipt>;
+    /**
+     * Awaits for a tx to be mined and returns the receipt. Throws if tx is not mined.
+     * @param opts - Options for configuring the waiting for the tx to be mined.
+     * @returns The transaction receipt.
+     */
+    wait(opts?: WaitOpts): Promise<FieldsOf<TxReceipt>>;
+    /**
+     * Gets public logs emitted by this tx.
+     * @remarks This function will wait for the tx to be mined if it hasn't been already.
+     * @returns The requested logs.
+     */
+    getPublicLogs(): Promise<GetPublicLogsResponse>;
+    protected waitForReceipt(opts?: WaitOpts): Promise<TxReceipt>;
+    protected waitForProven(minedBlock: number, opts?: WaitOpts): Promise<number>;
+}
+//# sourceMappingURL=sent_tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sent_tx.d.ts","sourceRoot":"","sources":["../../src/contract/sent_tx.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAC7F,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAY,MAAM,kBAAkB,CAAC;AAEzE,2CAA2C;AAC3C,MAAM,MAAM,QAAQ,GAAG;IACrB,gKAAgK;IAChK,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+FAA+F;IAC/F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sGAAsG;IACtG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kFAAkF;IAClF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0HAA0H;IAC1H,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAM7B,CAAC;AAEF;;;GAGG;AACH,qBAAa,MAAM;IACL,SAAS,CAAC,SAAS,EAAE,GAAG,GAAG,SAAS;IAAE,SAAS,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;gBAApE,SAAS,EAAE,GAAG,GAAG,SAAS,EAAY,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;IAE1F;;;;;;OAMG;IACI,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAInC;;;;;;OAMG;IACU,UAAU,IAAI,OAAO,CAAC,SAAS,CAAC;IAK7C;;;;OAIG;IACU,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAuBhE;;;;OAIG;IACU,aAAa,IAAI,OAAO,CAAC,qBAAqB,CAAC;cAK5C,cAAc,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;cA8BnD,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ;CAWlE"}

package/dest/contract/sent_tx.js

@@ -0,0 +1,102 @@
+import { retryUntil } from '@aztec/foundation/retry';
+import { TxStatus } from '@aztec/stdlib/tx';
+export const DefaultWaitOpts = {
+    ignoreDroppedReceiptsFor: 5,
+    timeout: 60,
+    provenTimeout: 600,
+    interval: 1,
+    debug: false
+};
+/**
+ * The SentTx class represents a sent transaction through the PXE (or directly to a node) providing methods to fetch
+ * its hash, receipt, and mining status.
+ */ export class SentTx {
+    pxeOrNode;
+    txHashPromise;
+    constructor(pxeOrNode, txHashPromise){
+        this.pxeOrNode = pxeOrNode;
+        this.txHashPromise = txHashPromise;
+    }
+    /**
+   * Retrieves the transaction hash of the SentTx instance.
+   * The function internally awaits for the 'txHashPromise' to resolve, and then returns the resolved transaction hash.
+   *
+   * @returns A promise that resolves to the transaction hash of the SentTx instance.
+   * TODO(#7717): Don't throw here.
+   */ getTxHash() {
+        return this.txHashPromise;
+    }
+    /**
+   * Retrieve the transaction receipt associated with the current SentTx instance.
+   * The function fetches the transaction hash using 'getTxHash' and then queries
+   * the PXE to get the corresponding transaction receipt.
+   *
+   * @returns A promise that resolves to a TxReceipt object representing the fetched transaction receipt.
+   */ async getReceipt() {
+        const txHash = await this.getTxHash();
+        return await this.pxeOrNode.getTxReceipt(txHash);
+    }
+    /**
+   * Awaits for a tx to be mined and returns the receipt. Throws if tx is not mined.
+   * @param opts - Options for configuring the waiting for the tx to be mined.
+   * @returns The transaction receipt.
+   */ async wait(opts) {
+        const receipt = await this.waitForReceipt(opts);
+        if (receipt.status !== TxStatus.SUCCESS && !opts?.dontThrowOnRevert) {
+            throw new Error(`Transaction ${await this.getTxHash()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`);
+        }
+        if (opts?.proven && receipt.blockNumber !== undefined) {
+            await this.waitForProven(receipt.blockNumber, opts);
+        }
+        if (opts?.debug) {
+            const txHash = await this.getTxHash();
+            const { data: tx } = await this.pxeOrNode.getTxEffect(txHash);
+            receipt.debugInfo = {
+                noteHashes: tx.noteHashes,
+                nullifiers: tx.nullifiers,
+                publicDataWrites: tx.publicDataWrites,
+                l2ToL1Msgs: tx.l2ToL1Msgs
+            };
+        }
+        return receipt;
+    }
+    /**
+   * Gets public logs emitted by this tx.
+   * @remarks This function will wait for the tx to be mined if it hasn't been already.
+   * @returns The requested logs.
+   */ async getPublicLogs() {
+        await this.wait();
+        return this.pxeOrNode.getPublicLogs({
+            txHash: await this.getTxHash()
+        });
+    }
+    async waitForReceipt(opts) {
+        const txHash = await this.getTxHash();
+        const startTime = Date.now();
+        const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
+        return await retryUntil(async ()=>{
+            const txReceipt = await this.pxeOrNode.getTxReceipt(txHash);
+            // If receipt is not yet available, try again
+            if (txReceipt.status === TxStatus.PENDING) {
+                return undefined;
+            }
+            // If the tx was "dropped", either return it or ignore based on timing.
+            // We can ignore it at first because the transaction may have been sent to node 1, and now we're asking node 2 for the receipt.
+            // If we don't allow a short grace period, we could incorrectly return a TxReceipt with status DROPPED.
+            if (txReceipt.status === TxStatus.DROPPED) {
+                const elapsedSeconds = (Date.now() - startTime) / 1000;
+                if (!ignoreDroppedReceiptsFor || elapsedSeconds > ignoreDroppedReceiptsFor) {
+                    return txReceipt;
+                }
+                return undefined;
+            }
+            return txReceipt;
+        }, 'isMined', opts?.timeout ?? DefaultWaitOpts.timeout, opts?.interval ?? DefaultWaitOpts.interval);
+    }
+    async waitForProven(minedBlock, opts) {
+        return await retryUntil(async ()=>{
+            const provenBlock = await this.pxeOrNode.getProvenBlockNumber();
+            return provenBlock >= minedBlock ? provenBlock : undefined;
+        }, 'isProven', opts?.provenTimeout ?? DefaultWaitOpts.provenTimeout, opts?.interval ?? DefaultWaitOpts.interval);
+    }
+}

package/dest/contract/unsafe_contract.d.ts

@@ -0,0 +1,15 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { Wallet } from '../wallet/index.js';
+import { ContractBase } from './contract_base.js';
+/** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */
+export declare class UnsafeContract extends ContractBase {
+    constructor(
+    /** The deployed contract instance definition. */
+    instance: ContractInstanceWithAddress, 
+    /** The Application Binary Interface for the contract. */
+    artifact: ContractArtifact, 
+    /** The wallet used for interacting with this contract. */
+    wallet: Wallet);
+}
+//# sourceMappingURL=unsafe_contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe_contract.d.ts","sourceRoot":"","sources":["../../src/contract/unsafe_contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,iHAAiH;AACjH,qBAAa,cAAe,SAAQ,YAAY;;IAE5C,iDAAiD;IACjD,QAAQ,EAAE,2BAA2B;IACrC,yDAAyD;IACzD,QAAQ,EAAE,gBAAgB;IAC1B,0DAA0D;IAC1D,MAAM,EAAE,MAAM;CAIjB"}

package/dest/contract/unsafe_contract.js

@@ -0,0 +1,6 @@
+import { ContractBase } from './contract_base.js';
+/** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */ export class UnsafeContract extends ContractBase {
+    constructor(/** The deployed contract instance definition. */ instance, /** The Application Binary Interface for the contract. */ artifact, /** The wallet used for interacting with this contract. */ wallet){
+        super(instance, artifact, wallet);
+    }
+}

package/dest/deployment/broadcast_function.d.ts

@@ -0,0 +1,24 @@
+import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import type { Wallet } from '../wallet/index.js';
+/**
+ * Sets up a call to broadcast a private function's bytecode via the ClassRegisterer contract.
+ * Note that this is not required for users to call the function, but is rather a convenience to make
+ * this code publicly available so dapps or wallets do not need to redistribute it.
+ * @param wallet - Wallet to send the transaction.
+ * @param artifact - Contract artifact that contains the function to be broadcast.
+ * @param selector - Selector of the function to be broadcast.
+ * @returns A ContractFunctionInteraction object that can be used to send the transaction.
+ */
+export declare function broadcastPrivateFunction(wallet: Wallet, artifact: ContractArtifact, selector: FunctionSelector): Promise<ContractFunctionInteraction>;
+/**
+ * Sets up a call to broadcast an unconstrained function's bytecode via the ClassRegisterer contract.
+ * Note that this is not required for users to call the function, but is rather a convenience to make
+ * this code publicly available so dapps or wallets do not need to redistribute it.
+ * @param wallet - Wallet to send the transaction.
+ * @param artifact - Contract artifact that contains the function to be broadcast.
+ * @param selector - Selector of the function to be broadcast.
+ * @returns A ContractFunctionInteraction object that can be used to send the transaction.
+ */
+export declare function broadcastUnconstrainedFunction(wallet: Wallet, artifact: ContractArtifact, selector: FunctionSelector): Promise<ContractFunctionInteraction>;
+//# sourceMappingURL=broadcast_function.d.ts.map

package/dest/deployment/broadcast_function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast_function.d.ts","sourceRoot":"","sources":["../../src/deployment/broadcast_function.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgC,MAAM,mBAAmB,CAAC;AAS1G,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAEhG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,2BAA2B,CAAC,CAoDtC;AAED;;;;;;;;GAQG;AACH,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,2BAA2B,CAAC,CA8CtC"}

package/dest/deployment/broadcast_function.js

@@ -0,0 +1,70 @@
+import { ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS, REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionSelector, FunctionType, bufferAsFields } from '@aztec/stdlib/abi';
+import { computeVerificationKeyHash, createPrivateFunctionMembershipProof, createUnconstrainedFunctionMembershipProof, getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { Capsule } from '@aztec/stdlib/tx';
+import { getRegistererContract } from '../contract/protocol_contracts.js';
+/**
+ * Sets up a call to broadcast a private function's bytecode via the ClassRegisterer contract.
+ * Note that this is not required for users to call the function, but is rather a convenience to make
+ * this code publicly available so dapps or wallets do not need to redistribute it.
+ * @param wallet - Wallet to send the transaction.
+ * @param artifact - Contract artifact that contains the function to be broadcast.
+ * @param selector - Selector of the function to be broadcast.
+ * @returns A ContractFunctionInteraction object that can be used to send the transaction.
+ */ export async function broadcastPrivateFunction(wallet, artifact, selector) {
+    const contractClass = await getContractClassFromArtifact(artifact);
+    const privateFunctions = artifact.functions.filter((fn)=>fn.functionType === FunctionType.PRIVATE);
+    const functionsAndSelectors = await Promise.all(privateFunctions.map(async (fn)=>({
+            f: fn,
+            selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)
+        })));
+    const privateFunctionArtifact = functionsAndSelectors.find((fn)=>selector.equals(fn.selector))?.f;
+    if (!privateFunctionArtifact) {
+        throw new Error(`Private function with selector ${selector.toString()} not found`);
+    }
+    const { artifactTreeSiblingPath, artifactTreeLeafIndex, artifactMetadataHash, functionMetadataHash, unconstrainedFunctionsArtifactTreeRoot, privateFunctionTreeSiblingPath, privateFunctionTreeLeafIndex } = await createPrivateFunctionMembershipProof(selector, artifact);
+    const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
+    const registerer = await getRegistererContract(wallet);
+    const fn = registerer.methods.broadcast_private_function(contractClass.id, artifactMetadataHash, unconstrainedFunctionsArtifactTreeRoot, privateFunctionTreeSiblingPath, privateFunctionTreeLeafIndex, padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT), artifactTreeLeafIndex, // eslint-disable-next-line camelcase
+    {
+        selector,
+        metadata_hash: functionMetadataHash,
+        vk_hash: vkHash
+    });
+    const bytecode = bufferAsFields(privateFunctionArtifact.bytecode, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS);
+    fn.addCapsule(new Capsule(ProtocolContractAddress.ContractClassRegisterer, new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT), bytecode));
+    return fn;
+}
+/**
+ * Sets up a call to broadcast an unconstrained function's bytecode via the ClassRegisterer contract.
+ * Note that this is not required for users to call the function, but is rather a convenience to make
+ * this code publicly available so dapps or wallets do not need to redistribute it.
+ * @param wallet - Wallet to send the transaction.
+ * @param artifact - Contract artifact that contains the function to be broadcast.
+ * @param selector - Selector of the function to be broadcast.
+ * @returns A ContractFunctionInteraction object that can be used to send the transaction.
+ */ export async function broadcastUnconstrainedFunction(wallet, artifact, selector) {
+    const contractClass = await getContractClassFromArtifact(artifact);
+    const unconstrainedFunctions = artifact.functions.filter((fn)=>fn.functionType === FunctionType.UNCONSTRAINED);
+    const unconstrainedFunctionsAndSelectors = await Promise.all(unconstrainedFunctions.map(async (fn)=>({
+            f: fn,
+            selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)
+        })));
+    const unconstrainedFunctionArtifact = unconstrainedFunctionsAndSelectors.find((fn)=>selector.equals(fn.selector))?.f;
+    if (!unconstrainedFunctionArtifact) {
+        throw new Error(`Unconstrained function with selector ${selector.toString()} not found`);
+    }
+    const { artifactMetadataHash, artifactTreeLeafIndex, artifactTreeSiblingPath, functionMetadataHash, privateFunctionsArtifactTreeRoot } = await createUnconstrainedFunctionMembershipProof(selector, artifact);
+    const registerer = await getRegistererContract(wallet);
+    const fn = registerer.methods.broadcast_unconstrained_function(contractClass.id, artifactMetadataHash, privateFunctionsArtifactTreeRoot, padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT), artifactTreeLeafIndex, // eslint-disable-next-line camelcase
+    {
+        selector,
+        metadata_hash: functionMetadataHash
+    });
+    const bytecode = bufferAsFields(unconstrainedFunctionArtifact.bytecode, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS);
+    fn.addCapsule(new Capsule(ProtocolContractAddress.ContractClassRegisterer, new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT), bytecode));
+    return fn;
+}

package/dest/deployment/contract_deployer.d.ts

@@ -0,0 +1,27 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { PublicKeys } from '@aztec/stdlib/keys';
+import type { Wallet } from '../account/wallet.js';
+import { Contract } from '../contract/contract.js';
+import { DeployMethod } from '../contract/deploy_method.js';
+/**
+ * A class for deploying contract.
+ * @remarks Keeping this around even though we have Aztec.nr contract types because it can be useful for non-TS users.
+ */
+export declare class ContractDeployer {
+    private artifact;
+    private wallet;
+    private publicKeys?;
+    private constructorName?;
+    constructor(artifact: ContractArtifact, wallet: Wallet, publicKeys?: PublicKeys | undefined, constructorName?: string | undefined);
+    /**
+     * Deploy a contract using the provided ABI and constructor arguments.
+     * This function creates a new DeployMethod instance that can be used to send deployment transactions
+     * and query deployment status. The method accepts any number of constructor arguments, which will
+     * be passed to the contract's constructor during deployment.
+     *
+     * @param args - The constructor arguments for the contract being deployed.
+     * @returns A DeployMethod instance configured with the ABI, PXE, and constructor arguments.
+     */
+    deploy(...args: any[]): DeployMethod<Contract>;
+}
+//# sourceMappingURL=contract_deployer.d.ts.map

package/dest/deployment/contract_deployer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_deployer.d.ts","sourceRoot":"","sources":["../../src/deployment/contract_deployer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D;;;GAGG;AACH,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU,CAAC;IACnB,OAAO,CAAC,eAAe,CAAC;gBAHhB,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,wBAAY,EACvB,eAAe,CAAC,oBAAQ;IAGlC;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;CAW7B"}

package/dest/deployment/contract_deployer.js

@@ -0,0 +1,30 @@
+import { PublicKeys } from '@aztec/stdlib/keys';
+import { Contract } from '../contract/contract.js';
+import { DeployMethod } from '../contract/deploy_method.js';
+/**
+ * A class for deploying contract.
+ * @remarks Keeping this around even though we have Aztec.nr contract types because it can be useful for non-TS users.
+ */ export class ContractDeployer {
+    artifact;
+    wallet;
+    publicKeys;
+    constructorName;
+    constructor(artifact, wallet, publicKeys, constructorName){
+        this.artifact = artifact;
+        this.wallet = wallet;
+        this.publicKeys = publicKeys;
+        this.constructorName = constructorName;
+    }
+    /**
+   * Deploy a contract using the provided ABI and constructor arguments.
+   * This function creates a new DeployMethod instance that can be used to send deployment transactions
+   * and query deployment status. The method accepts any number of constructor arguments, which will
+   * be passed to the contract's constructor during deployment.
+   *
+   * @param args - The constructor arguments for the contract being deployed.
+   * @returns A DeployMethod instance configured with the ABI, PXE, and constructor arguments.
+   */ deploy(...args) {
+        const postDeployCtor = (address, wallet)=>Contract.at(address, this.artifact, wallet);
+        return new DeployMethod(this.publicKeys ?? PublicKeys.default(), this.wallet, this.artifact, postDeployCtor, args, this.constructorName);
+    }
+}

package/dest/deployment/deploy_instance.d.ts

@@ -0,0 +1,10 @@
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import type { Wallet } from '../wallet/index.js';
+/**
+ * Sets up a call to the canonical deployer contract to publicly deploy a contract instance.
+ * @param wallet - The wallet to use for the deployment.
+ * @param instance - The instance to deploy.
+ */
+export declare function deployInstance(wallet: Wallet, instance: ContractInstanceWithAddress): Promise<ContractFunctionInteraction>;
+//# sourceMappingURL=deploy_instance.d.ts.map