@walletmesh/aztec-rpc-wallet 0.3.1 → 0.4.0

package/dist/wallet/handlers/contract-interaction.js

@@ -0,0 +1,219 @@
+import { Contract, FeeJuicePaymentMethod, Fr } from '@aztec/aztec.js';
+import { GasSettings } from '@aztec/stdlib/gas';
+import { createLogger } from '@aztec/foundation/log';
+const logger = createLogger('aztec-rpc-wallet:contract-interaction:handler');
+/**
+ * @module @walletmesh/aztec-rpc-wallet/wallet/handlers/contract-interaction
+ * This module provides handlers for WalletMesh-specific high-level contract
+ * interaction and deployment methods (e.g., `aztec_wmExecuteTx`, `aztec_wmDeployContract`).
+ * These methods simplify common contract operations for dApp developers by accepting
+ * an {@link ExecutionPayload} or deployment parameters, with the wallet-side
+ * handling more of the transaction construction, simulation, proving, and sending flow.
+ */
+/**
+ * Creates handlers for WalletMesh-specific contract interaction and deployment JSON-RPC methods.
+ *
+ * These handlers manage high-level contract operations such as:
+ * - `aztec_wmExecuteTx`: Executing a pre-constructed {@link ExecutionPayload}.
+ * - `aztec_wmSimulateTx`: Simulating an {@link ExecutionPayload}.
+ * - `aztec_wmDeployContract`: Deploying a new contract from its artifact and arguments.
+ *
+ * The primary goal of these "wm" (WalletMesh) methods is to simplify the dApp's
+ * interaction with the wallet by abstracting parts of the standard Aztec transaction
+ * lifecycle (e.g., fee estimation, `createTxExecutionRequest`, `proveTx`, `sendTx`).
+ * The wallet takes on more responsibility, which can lead to a better user experience
+ * as the wallet can provide more context or apply its own policies.
+ *
+ * @returns An object where keys are "wm" prefixed method names and values are their
+ *          corresponding handler functions.
+ * @see {@link AztecWalletMethodMap} for method definitions.
+ */
+export function createContractInteractionHandlers() {
+    /** @internal Helper to configure fee options. TODO: Make this more configurable. */
+    async function getFeeOptions(ctx) {
+        // TODO: Provide gas settings from the context
+        logger.debug('Getting current base fees...');
+        const baseFees = await ctx.wallet.getCurrentBaseFees();
+        logger.debug('Base fees:', baseFees);
+        const maxFeesPerGas = baseFees.mul(1.5);
+        logger.debug('Calculated max fees per gas:', maxFeesPerGas);
+        const feeOpts = {
+            paymentMethod: new FeeJuicePaymentMethod(ctx.wallet.getAddress()),
+            gasSettings: GasSettings.default({ maxFeesPerGas }),
+        };
+        logger.debug('Fee options configured:', feeOpts);
+        return feeOpts;
+    }
+    /** @internal Helper to configure transaction execution options. TODO: Make this more configurable. */
+    async function getTxOptions(_ctx) {
+        // TODO(twt): Enable setting cancellable flag & nonce in the options
+        const txOpts = {};
+        return txOpts;
+    }
+    async function createTxExecutionRequest(ctx, executionPayload) {
+        logger.debug('Creating transaction execution request...');
+        try {
+            // TODO(twt): Provide gas settings from the context
+            logger.debug('Getting current base fees...');
+            const baseFees = await ctx.wallet.getCurrentBaseFees();
+            logger.debug('Base fees:', baseFees);
+            const maxFeesPerGas = baseFees.mul(1.5);
+            logger.debug('Calculated max fees per gas:', maxFeesPerGas);
+            const feeOpts = await getFeeOptions(ctx);
+            const txOpts = await getTxOptions(ctx);
+            // Create a transaction execution request from the payload
+            const txRequest = await ctx.wallet.createTxExecutionRequest(executionPayload, feeOpts, txOpts);
+            return txRequest;
+        }
+        catch (error) {
+            logger.error('Failed to create transaction execution request:', error);
+            throw error;
+        }
+    }
+    async function simulateTransaction(ctx, executionPayload, txExecutionRequest) {
+        try {
+            const txRequest = txExecutionRequest || (await createTxExecutionRequest(ctx, executionPayload));
+            // Execute the transaction using the standard flow
+            logger.debug('Starting transaction simulation...');
+            const simStartTime = Date.now();
+            const simulationResult = await ctx.wallet.simulateTx(txRequest, true);
+            logger.debug(`Transaction simulation completed in ${Date.now() - simStartTime}ms`);
+            return simulationResult;
+        }
+        catch (error) {
+            logger.error('Transaction simulation failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * @internal
+     * Helper function to execute a transaction from an {@link ExecutionPayload}.
+     * This consolidates the common flow:
+     * 1. Create TxExecutionRequest (if needed, though typically done by `aztec_wmExecuteTx` caller or here).
+     * 2. Simulate transaction.
+     * 3. Prove transaction.
+     * 4. Send transaction.
+     *
+     * @param ctx - The {@link AztecHandlerContext}.
+     * @param executionPayload - The {@link ExecutionPayload} for the transaction.
+     * @returns A promise resolving to the {@link TxHash} of the sent transaction.
+     */
+    async function executeTransaction(ctx, executionPayload) {
+        const startTime = Date.now();
+        logger.debug(`Starting transaction execution. Wallet: ${ctx.wallet.getAddress().toString()}, Payload: ${executionPayload.calls.length} calls`);
+        logger.debug('Execution payload:', executionPayload);
+        try {
+            const txRequest = await createTxExecutionRequest(ctx, executionPayload);
+            const simulationResult = await simulateTransaction(ctx, executionPayload, txRequest);
+            logger.debug('Starting transaction proving...');
+            const proveStartTime = Date.now();
+            const provingResult = await ctx.wallet.proveTx(txRequest, simulationResult.privateExecutionResult);
+            logger.debug(`Transaction proving completed in ${Date.now() - proveStartTime}ms`);
+            logger.debug('Proving result:', provingResult);
+            logger.debug('Creating transaction from proving result...');
+            const tx = provingResult.toTx();
+            logger.debug('Transaction created:', tx);
+            logger.debug('Sending transaction to network...');
+            const sendStartTime = Date.now();
+            const txHash = await ctx.wallet.sendTx(tx);
+            logger.debug(`Transaction sent in ${Date.now() - sendStartTime}ms, hash: ${txHash.toString()}`);
+            return txHash;
+        }
+        catch (error) {
+            const totalTime = Date.now() - startTime;
+            logger.error(`Transaction execution failed after ${totalTime}ms}`);
+            logger.error('Error details:', error);
+            throw error;
+        }
+    }
+    return {
+        /**
+         * Handles the "aztec_wmExecuteTx" JSON-RPC method.
+         * This WalletMesh-specific method takes an {@link ExecutionPayload} and handles
+         * the full lifecycle of simulating, proving, and sending the transaction.
+         *
+         * @param ctx - The {@link AztecHandlerContext}.
+         * @param paramsTuple - A tuple containing the {@link ExecutionPayload}.
+         *                      Defined by {@link AztecWalletMethodMap.aztec_wmExecuteTx.params}.
+         * @param paramsTuple.0 - The {@link ExecutionPayload} to execute.
+         * @returns A promise that resolves to the {@link TxHash} of the sent transaction.
+         *          Type defined by {@link AztecWalletMethodMap.aztec_wmExecuteTx.result}.
+         */
+        aztec_wmExecuteTx: async (ctx, paramsTuple) => {
+            const [executionPayload] = paramsTuple;
+            return executeTransaction(ctx, executionPayload);
+        },
+        /**
+         * Handles the "aztec_wmSimulateTx" JSON-RPC method.
+         * This WalletMesh-specific method takes an {@link ExecutionPayload} and simulates
+         * the transaction, returning the {@link TxSimulationResult}.
+         *
+         * @param ctx - The {@link AztecHandlerContext}.
+         * @param paramsTuple - A tuple containing the {@link ExecutionPayload}.
+         *                      Defined by {@link AztecWalletMethodMap.aztec_wmSimulateTx.params}.
+         * @param paramsTuple.0 - The {@link ExecutionPayload} to simulate.
+         * @returns A promise that resolves to the {@link TxSimulationResult}.
+         *          Type defined by {@link AztecWalletMethodMap.aztec_wmSimulateTx.result}.
+         */
+        aztec_wmSimulateTx: async (ctx, paramsTuple) => {
+            const [executionPayload] = paramsTuple;
+            return await simulateTransaction(ctx, executionPayload);
+        },
+        /**
+         * Handles the "aztec_wmDeployContract" JSON-RPC method.
+         * This WalletMesh-specific method deploys a new contract using its {@link ContractArtifact}
+         * and constructor arguments. It manages the deployment transaction lifecycle, including
+         * computing the contract address, proving, and sending the deployment transaction.
+         *
+         * Fee configuration is determined internally by the `getFeeOptions` helper.
+         *
+         * @param ctx - The {@link AztecHandlerContext}.
+         * @param paramsTuple - A tuple containing the deployment parameters (artifact, args, constructorName).
+         *                      Defined by {@link AztecWalletMethodMap.aztec_wmDeployContract.params}.
+         * @param paramsTuple.0.artifact - The {@link ContractArtifact} of the contract to deploy.
+         * @param paramsTuple.0.args - An array of arguments for the contract's constructor.
+         * @param paramsTuple.0.constructorName - Optional name of the constructor function if the artifact has multiple.
+         * @returns A promise that resolves to an object containing the `txHash` ({@link TxHash})
+         *          of the deployment transaction and the `contractAddress` ({@link AztecAddress})
+         *          of the newly deployed contract.
+         *          Type defined by {@link AztecWalletMethodMap.aztec_wmDeployContract.result}.
+         */
+        aztec_wmDeployContract: async (ctx, paramsTuple) => {
+            const [params] = paramsTuple;
+            const { artifact, args, constructorName } = params;
+            logger.debug(`aztec_wmDeployContract: deploying ${artifact.name} with ${args.length} args`);
+            try {
+                // Create deployment method using the server-side wallet
+                const deployMethod = Contract.deploy(ctx.wallet, artifact, args, constructorName);
+                const contractAddressSalt = Fr.random();
+                const txOpts = await getTxOptions(ctx);
+                const opts = {
+                    contractAddressSalt,
+                    fee: await getFeeOptions(ctx),
+                };
+                if (txOpts.nonce) {
+                    opts.nonce = txOpts.nonce;
+                }
+                if (txOpts.cancellable) {
+                    opts.cancellable = txOpts.cancellable;
+                }
+                // Compute the contract address
+                const { address: contractAddress } = await deployMethod.getInstance(opts);
+                logger.debug(`Computed contract address: ${contractAddress.toString()}`);
+                const deployProvenTx = await deployMethod.prove(opts);
+                const deploySentTx = await deployProvenTx.send();
+                const txHash = await deploySentTx.getTxHash();
+                logger.debug(`Contract deployed, hash: ${txHash.toString()}`);
+                return {
+                    txHash,
+                    contractAddress,
+                };
+            }
+            catch (error) {
+                logger.error(`Contract deployment failed for ${artifact.name}:`, error);
+                throw error;
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/wallet/handlers/contract.d.ts

@@ -0,0 +1,96 @@
+import type { AztecWalletMethodMap } from '../../types.js';
+import type { AztecHandlerContext } from './index.js';
+/**
+ * Creates handlers for contract-related Aztec wallet JSON-RPC methods.
+ * These handlers are responsible for managing the registration of deployed contract
+ * instances and contract classes (artifacts), as well as retrieving contract metadata.
+ *
+ * Each handler function receives an {@link AztecHandlerContext} which provides access
+ * to the {@link AccountWallet}, {@link PXE} client, and {@link ContractArtifactCache}.
+ *
+ * @returns An object where keys are contract-related method names
+ *          (e.g., "aztec_registerContract", "aztec_getContractMetadata") and values
+ *          are their corresponding handler functions.
+ * @see {@link AztecWalletMethodMap} for method definitions.
+ */
+export declare function createContractHandlers(): {
+    /**
+     * Handles the "aztec_registerContract" JSON-RPC method.
+     * Registers a deployed contract instance with the {@link AccountWallet} in the context.
+     * This allows the wallet to be aware of and interact with the specified contract.
+     * An optional {@link ContractArtifact} can be provided to include ABI information.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the contract instance and optional artifact.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_registerContract.params}.
+     * @param paramsTuple.0 - The {@link ContractInstanceWithAddress} to register.
+     * @param paramsTuple.1 - Optional: The {@link ContractArtifact} associated with the instance.
+     * @returns A promise that resolves to `true` if the registration was successful.
+     * @throws {Error} If critical parameters like `instance` are missing or invalid,
+     *                 though type checking and serializer validation should catch this earlier.
+     */
+    aztec_registerContract: (ctx: AztecHandlerContext, paramsTuple: AztecWalletMethodMap["aztec_registerContract"]["params"]) => Promise<AztecWalletMethodMap["aztec_registerContract"]["result"]>;
+    /**
+     * Handles the "aztec_registerContractClass" JSON-RPC method.
+     * Registers a contract class (defined by its {@link ContractArtifact}) with the
+     * {@link AccountWallet} in the context. This makes the contract's bytecode and ABI
+     * known to the wallet, typically for future deployments or interactions.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the contract artifact.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_registerContractClass.params}.
+     * @param paramsTuple.0 - The {@link ContractArtifact} to register.
+     * @returns A promise that resolves to `true` if the registration was successful.
+     * @throws {Error} If the `artifact` parameter is missing or invalid,
+     *                 though type checking and serializer validation should catch this earlier.
+     */
+    aztec_registerContractClass: (ctx: AztecHandlerContext, paramsTuple: AztecWalletMethodMap["aztec_registerContractClass"]["params"]) => Promise<AztecWalletMethodMap["aztec_registerContractClass"]["result"]>;
+    /**
+     * Handles the "aztec_getContractMetadata" JSON-RPC method.
+     * Retrieves {@link ContractMetadata} for a deployed contract at a given {@link AztecAddress},
+     * using the {@link AccountWallet} in the context.
+     *
+     * Contract metadata typically includes information about the contract's instance,
+     * initialization status, and public deployment status.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the contract address.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_getContractMetadata.params}.
+     * @param paramsTuple.0 - The {@link AztecAddress} of the contract.
+     * @returns A promise that resolves to the {@link ContractMetadata}.
+     * @throws {Error} If the `address` parameter is missing or invalid, or if metadata is not found.
+     */
+    aztec_getContractMetadata: (ctx: AztecHandlerContext, paramsTuple: AztecWalletMethodMap["aztec_getContractMetadata"]["params"]) => Promise<AztecWalletMethodMap["aztec_getContractMetadata"]["result"]>;
+    /**
+     * Handles the "aztec_getContracts" JSON-RPC method.
+     * Retrieves a list of {@link AztecAddress}es for all contracts known to the {@link PXE}
+     * instance in the current context. This typically includes contracts that have been
+     * registered or deployed through this PXE.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `pxe` instance.
+     * @param _paramsTuple - Parameters for this method (expected to be an empty array).
+     *                       Defined by {@link AztecWalletMethodMap.aztec_getContracts.params}.
+     * @returns A promise that resolves to an array of {@link AztecAddress} objects.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_getContracts.result}.
+     */
+    aztec_getContracts: (ctx: AztecHandlerContext, _paramsTuple: AztecWalletMethodMap["aztec_getContracts"]["params"]) => Promise<AztecWalletMethodMap["aztec_getContracts"]["result"]>;
+    /**
+     * Handles the "aztec_getContractClassMetadata" JSON-RPC method.
+     * Retrieves {@link ContractClassMetadata} for a contract class identified by its {@link Fr} ID,
+     * using the {@link AccountWallet} in the context.
+     *
+     * Contract class metadata provides information about a registered contract class,
+     * potentially including its artifact if requested.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the class ID and an optional flag to include the artifact.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_getContractClassMetadata.params}.
+     * @param paramsTuple.0 - The {@link Fr} ID of the contract class.
+     * @param paramsTuple.1 - Optional: A boolean indicating whether to include the full {@link ContractArtifact}
+     *                        in the returned metadata. Defaults to `false`.
+     * @returns A promise that resolves to the {@link ContractClassMetadata}.
+     * @throws {Error} If the `id` parameter is missing or invalid.
+     */
+    aztec_getContractClassMetadata: (ctx: AztecHandlerContext, paramsTuple: AztecWalletMethodMap["aztec_getContractClassMetadata"]["params"]) => Promise<AztecWalletMethodMap["aztec_getContractClassMetadata"]["result"]>;
+};
+//# sourceMappingURL=contract.d.ts.map

package/dist/wallet/handlers/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/wallet/handlers/contract.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAKtD;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB;IAElC;;;;;;;;;;;;;;OAcG;kCAEI,mBAAmB,eACX,oBAAoB,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,KACpE,OAAO,CAAC,oBAAoB,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,CAAC;IAmBpE;;;;;;;;;;;;;OAaG;uCAEI,mBAAmB,eACX,oBAAoB,CAAC,6BAA6B,CAAC,CAAC,QAAQ,CAAC,KACzE,OAAO,CAAC,oBAAoB,CAAC,6BAA6B,CAAC,CAAC,QAAQ,CAAC,CAAC;IAQzE;;;;;;;;;;;;;;OAcG;qCAEI,mBAAmB,eACX,oBAAoB,CAAC,2BAA2B,CAAC,CAAC,QAAQ,CAAC,KACvE,OAAO,CAAC,oBAAoB,CAAC,2BAA2B,CAAC,CAAC,QAAQ,CAAC,CAAC;IAgBvE;;;;;;;;;;;OAWG;8BAEI,mBAAmB,gBACV,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,QAAQ,CAAC,KACjE,OAAO,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,QAAQ,CAAC,CAAC;IAKhE;;;;;;;;;;;;;;;;OAgBG;0CAEI,mBAAmB,eACX,oBAAoB,CAAC,gCAAgC,CAAC,CAAC,QAAQ,CAAC,KAC5E,OAAO,CAAC,oBAAoB,CAAC,gCAAgC,CAAC,CAAC,QAAQ,CAAC,CAAC;EAc/E"}

package/dist/wallet/handlers/contract.js

@@ -0,0 +1,146 @@
+import { createLogger } from '@aztec/foundation/log';
+const logger = createLogger('aztec-rpc-wallet:contract');
+/**
+ * Creates handlers for contract-related Aztec wallet JSON-RPC methods.
+ * These handlers are responsible for managing the registration of deployed contract
+ * instances and contract classes (artifacts), as well as retrieving contract metadata.
+ *
+ * Each handler function receives an {@link AztecHandlerContext} which provides access
+ * to the {@link AccountWallet}, {@link PXE} client, and {@link ContractArtifactCache}.
+ *
+ * @returns An object where keys are contract-related method names
+ *          (e.g., "aztec_registerContract", "aztec_getContractMetadata") and values
+ *          are their corresponding handler functions.
+ * @see {@link AztecWalletMethodMap} for method definitions.
+ */
+export function createContractHandlers() {
+    return {
+        /**
+         * Handles the "aztec_registerContract" JSON-RPC method.
+         * Registers a deployed contract instance with the {@link AccountWallet} in the context.
+         * This allows the wallet to be aware of and interact with the specified contract.
+         * An optional {@link ContractArtifact} can be provided to include ABI information.
+         *
+         * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+         * @param paramsTuple - A tuple containing the contract instance and optional artifact.
+         *                      Defined by {@link AztecWalletMethodMap.aztec_registerContract.params}.
+         * @param paramsTuple.0 - The {@link ContractInstanceWithAddress} to register.
+         * @param paramsTuple.1 - Optional: The {@link ContractArtifact} associated with the instance.
+         * @returns A promise that resolves to `true` if the registration was successful.
+         * @throws {Error} If critical parameters like `instance` are missing or invalid,
+         *                 though type checking and serializer validation should catch this earlier.
+         */
+        aztec_registerContract: async (ctx, paramsTuple) => {
+            const [instance, artifact] = paramsTuple;
+            logger.debug(`[HANDLER] aztec_registerContract: instance = ${instance?.address?.toString()}, artifact provided = ${!!artifact}`);
+            // Original logic used `instance === undefined` check, but instance is not optional in the tuple.
+            // The type system should ensure `instance` is provided.
+            // If `instance` itself could be undefined in the tuple, the tuple type would be `[ContractInstanceWithAddress | undefined, ...]`.
+            // Assuming `instance` is guaranteed by the tuple type.
+            const contractToRegister = {
+                instance,
+            };
+            if (artifact) {
+                contractToRegister.artifact = artifact;
+            }
+            await ctx.wallet.registerContract(contractToRegister);
+            return true;
+        },
+        /**
+         * Handles the "aztec_registerContractClass" JSON-RPC method.
+         * Registers a contract class (defined by its {@link ContractArtifact}) with the
+         * {@link AccountWallet} in the context. This makes the contract's bytecode and ABI
+         * known to the wallet, typically for future deployments or interactions.
+         *
+         * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+         * @param paramsTuple - A tuple containing the contract artifact.
+         *                      Defined by {@link AztecWalletMethodMap.aztec_registerContractClass.params}.
+         * @param paramsTuple.0 - The {@link ContractArtifact} to register.
+         * @returns A promise that resolves to `true` if the registration was successful.
+         * @throws {Error} If the `artifact` parameter is missing or invalid,
+         *                 though type checking and serializer validation should catch this earlier.
+         */
+        aztec_registerContractClass: async (ctx, paramsTuple) => {
+            const [artifact] = paramsTuple;
+            logger.debug(`[HANDLER] aztec_registerContractClass: artifact name = ${artifact?.name}`);
+            // Artifact is not optional in the tuple type.
+            await ctx.wallet.registerContractClass(artifact);
+            return true;
+        },
+        /**
+         * Handles the "aztec_getContractMetadata" JSON-RPC method.
+         * Retrieves {@link ContractMetadata} for a deployed contract at a given {@link AztecAddress},
+         * using the {@link AccountWallet} in the context.
+         *
+         * Contract metadata typically includes information about the contract's instance,
+         * initialization status, and public deployment status.
+         *
+         * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+         * @param paramsTuple - A tuple containing the contract address.
+         *                      Defined by {@link AztecWalletMethodMap.aztec_getContractMetadata.params}.
+         * @param paramsTuple.0 - The {@link AztecAddress} of the contract.
+         * @returns A promise that resolves to the {@link ContractMetadata}.
+         * @throws {Error} If the `address` parameter is missing or invalid, or if metadata is not found.
+         */
+        aztec_getContractMetadata: async (ctx, paramsTuple) => {
+            const [address] = paramsTuple;
+            logger.debug(`[HANDLER] aztec_getContractMetadata: address = ${address?.toString()}`);
+            // Address is not optional in the tuple type.
+            // Add runtime check for robustness if needed, though TS should catch it.
+            if (!address || typeof address.toString !== 'function') {
+                // Basic check
+                throw new Error('Invalid address parameter received in tuple');
+            }
+            const metadata = await ctx.wallet.getContractMetadata(address);
+            if (!metadata) {
+                throw new Error(`Contract metadata not found for address: ${address.toString()}`);
+            }
+            return metadata;
+        },
+        /**
+         * Handles the "aztec_getContracts" JSON-RPC method.
+         * Retrieves a list of {@link AztecAddress}es for all contracts known to the {@link PXE}
+         * instance in the current context. This typically includes contracts that have been
+         * registered or deployed through this PXE.
+         *
+         * @param ctx - The {@link AztecHandlerContext} containing the `pxe` instance.
+         * @param _paramsTuple - Parameters for this method (expected to be an empty array).
+         *                       Defined by {@link AztecWalletMethodMap.aztec_getContracts.params}.
+         * @returns A promise that resolves to an array of {@link AztecAddress} objects.
+         *          Type defined by {@link AztecWalletMethodMap.aztec_getContracts.result}.
+         */
+        aztec_getContracts: async (ctx, _paramsTuple) => {
+            logger.debug('[HANDLER] aztec_getContracts');
+            return await ctx.pxe.getContracts();
+        },
+        /**
+         * Handles the "aztec_getContractClassMetadata" JSON-RPC method.
+         * Retrieves {@link ContractClassMetadata} for a contract class identified by its {@link Fr} ID,
+         * using the {@link AccountWallet} in the context.
+         *
+         * Contract class metadata provides information about a registered contract class,
+         * potentially including its artifact if requested.
+         *
+         * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+         * @param paramsTuple - A tuple containing the class ID and an optional flag to include the artifact.
+         *                      Defined by {@link AztecWalletMethodMap.aztec_getContractClassMetadata.params}.
+         * @param paramsTuple.0 - The {@link Fr} ID of the contract class.
+         * @param paramsTuple.1 - Optional: A boolean indicating whether to include the full {@link ContractArtifact}
+         *                        in the returned metadata. Defaults to `false`.
+         * @returns A promise that resolves to the {@link ContractClassMetadata}.
+         * @throws {Error} If the `id` parameter is missing or invalid.
+         */
+        aztec_getContractClassMetadata: async (ctx, paramsTuple) => {
+            const [id, includeArtifactInput] = paramsTuple;
+            const includeArtifact = includeArtifactInput === undefined ? false : includeArtifactInput; // Default for optional
+            logger.debug(`[HANDLER] aztec_getContractClassMetadata: id = ${id?.toString()}, includeArtifact = ${includeArtifact}`);
+            // Id is not optional in the tuple type.
+            if (!id || typeof id.toString !== 'function') {
+                // Basic check for Fr-like object
+                throw new Error('Invalid id parameter received in tuple');
+            }
+            return await ctx.wallet.getContractClassMetadata(id, includeArtifact);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/wallet/handlers/event.d.ts

@@ -0,0 +1,62 @@
+import type { AztecHandlerContext } from './index.js';
+import type { AztecWalletMethodMap } from '../../types.js';
+/**
+ * Creates handlers for event-related Aztec wallet JSON-RPC methods.
+ * These handlers are responsible for querying private (encrypted) and public
+ * (unencrypted) events emitted by Aztec contracts.
+ *
+ * Each handler function receives an {@link AztecHandlerContext} which provides access
+ * to the {@link PXE} client, essential for event retrieval.
+ *
+ * @returns An object where keys are event-related method names
+ *          (e.g., "aztec_getPrivateEvents", "aztec_getPublicEvents") and values are
+ *          their corresponding handler functions.
+ * @see {@link AztecWalletMethodMap} for method definitions.
+ */
+export declare function createEventHandlers(): {
+    /**
+     * Handles the "aztec_getPrivateEvents" JSON-RPC method.
+     * Retrieves encrypted private events emitted by a specific contract within a given
+     * block range, for a specified set of recipients.
+     *
+     * Private events are decrypted by the {@link PXE} using the viewing keys
+     * associated with the recipient addresses.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `pxe` instance.
+     * @param paramsTuple - A tuple containing parameters for querying private events.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_getPrivateEvents.params}.
+     * @param paramsTuple.0 - The {@link AztecAddress} of the contract that emitted the events.
+     * @param paramsTuple.1 - The {@link EventMetadataDefinition} describing the event structure.
+     * @param paramsTuple.2 - The starting block number (inclusive) from which to query.
+     * @param paramsTuple.3 - The number of blocks to scan from the `from` block.
+     * @param paramsTuple.4 - An array of {@link AztecAddress} recipients whose events are to be fetched and decrypted.
+     * @returns A promise that resolves to an array of decoded private event data. The specific type
+     *          of the event data depends on the `eventMetadata`.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_getPrivateEvents.result}.
+     * @throws {Error} If any required parameters are missing or invalid, though type checking
+     *                 and serializer validation should catch this earlier.
+     */
+    aztec_getPrivateEvents: (ctx: AztecHandlerContext, paramsTuple: AztecWalletMethodMap["aztec_getPrivateEvents"]["params"]) => Promise<AztecWalletMethodMap["aztec_getPrivateEvents"]["result"]>;
+    /**
+     * Handles the "aztec_getPublicEvents" JSON-RPC method.
+     * Retrieves unencrypted public events matching a specific {@link EventMetadataDefinition}
+     * starting from a given block number, up to a specified limit.
+     *
+     * Public events are visible to all network participants and are typically used for
+     * information that does not require privacy.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `pxe` instance.
+     * @param paramsTuple - A tuple containing parameters for querying public events.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_getPublicEvents.params}.
+     * @param paramsTuple.0 - The {@link EventMetadataDefinition} describing the event structure.
+     * @param paramsTuple.1 - The starting block number (inclusive) from which to query.
+     * @param paramsTuple.2 - The maximum number of events to return.
+     * @returns A promise that resolves to an array of decoded public event data. The specific type
+     *          of the event data depends on the `eventMetadata`.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_getPublicEvents.result}.
+     * @throws {Error} If any required parameters are missing or invalid, though type checking
+     *                 and serializer validation should catch this earlier.
+     */
+    aztec_getPublicEvents: (ctx: AztecHandlerContext, paramsTuple: AztecWalletMethodMap["aztec_getPublicEvents"]["params"]) => Promise<AztecWalletMethodMap["aztec_getPublicEvents"]["result"]>;
+};
+//# sourceMappingURL=event.d.ts.map

package/dist/wallet/handlers/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../src/wallet/handlers/event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAK3D;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB;IAE/B;;;;;;;;;;;;;;;;;;;;;OAqBG;kCAEI,mBAAmB,eACX,oBAAoB,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,KACpE,OAAO,CAAC,oBAAoB,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,CAAC;IAmBpE;;;;;;;;;;;;;;;;;;;OAmBG;iCAEI,mBAAmB,eACX,oBAAoB,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC,KACnE,OAAO,CAAC,oBAAoB,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC,CAAC;EAUtE"}

package/dist/wallet/handlers/event.js

@@ -0,0 +1,85 @@
+import { createLogger } from '@aztec/foundation/log';
+const logger = createLogger('aztec-rpc-wallet:event');
+/**
+ * Creates handlers for event-related Aztec wallet JSON-RPC methods.
+ * These handlers are responsible for querying private (encrypted) and public
+ * (unencrypted) events emitted by Aztec contracts.
+ *
+ * Each handler function receives an {@link AztecHandlerContext} which provides access
+ * to the {@link PXE} client, essential for event retrieval.
+ *
+ * @returns An object where keys are event-related method names
+ *          (e.g., "aztec_getPrivateEvents", "aztec_getPublicEvents") and values are
+ *          their corresponding handler functions.
+ * @see {@link AztecWalletMethodMap} for method definitions.
+ */
+export function createEventHandlers() {
+    return {
+        /**
+         * Handles the "aztec_getPrivateEvents" JSON-RPC method.
+         * Retrieves encrypted private events emitted by a specific contract within a given
+         * block range, for a specified set of recipients.
+         *
+         * Private events are decrypted by the {@link PXE} using the viewing keys
+         * associated with the recipient addresses.
+         *
+         * @param ctx - The {@link AztecHandlerContext} containing the `pxe` instance.
+         * @param paramsTuple - A tuple containing parameters for querying private events.
+         *                      Defined by {@link AztecWalletMethodMap.aztec_getPrivateEvents.params}.
+         * @param paramsTuple.0 - The {@link AztecAddress} of the contract that emitted the events.
+         * @param paramsTuple.1 - The {@link EventMetadataDefinition} describing the event structure.
+         * @param paramsTuple.2 - The starting block number (inclusive) from which to query.
+         * @param paramsTuple.3 - The number of blocks to scan from the `from` block.
+         * @param paramsTuple.4 - An array of {@link AztecAddress} recipients whose events are to be fetched and decrypted.
+         * @returns A promise that resolves to an array of decoded private event data. The specific type
+         *          of the event data depends on the `eventMetadata`.
+         *          Type defined by {@link AztecWalletMethodMap.aztec_getPrivateEvents.result}.
+         * @throws {Error} If any required parameters are missing or invalid, though type checking
+         *                 and serializer validation should catch this earlier.
+         */
+        aztec_getPrivateEvents: async (ctx, paramsTuple) => {
+            const [contractAddress, eventMetadata, from, numBlocks, recipients] = paramsTuple;
+            logger.debug(`[HANDLER] aztec_getPrivateEvents: contractAddress = ${contractAddress?.toString()}, from = ${from}, numBlocks = ${numBlocks}`);
+            // All parameters are mandatory in the tuple type definition.
+            // Add runtime checks if there's any doubt about them being undefined, though TS should catch.
+            if (!contractAddress ||
+                !eventMetadata ||
+                from === undefined ||
+                numBlocks === undefined ||
+                !recipients) {
+                throw new Error('Invalid parameters received in tuple for aztec_getPrivateEvents');
+            }
+            return await ctx.pxe.getPrivateEvents(contractAddress, eventMetadata, from, numBlocks, recipients);
+        },
+        /**
+         * Handles the "aztec_getPublicEvents" JSON-RPC method.
+         * Retrieves unencrypted public events matching a specific {@link EventMetadataDefinition}
+         * starting from a given block number, up to a specified limit.
+         *
+         * Public events are visible to all network participants and are typically used for
+         * information that does not require privacy.
+         *
+         * @param ctx - The {@link AztecHandlerContext} containing the `pxe` instance.
+         * @param paramsTuple - A tuple containing parameters for querying public events.
+         *                      Defined by {@link AztecWalletMethodMap.aztec_getPublicEvents.params}.
+         * @param paramsTuple.0 - The {@link EventMetadataDefinition} describing the event structure.
+         * @param paramsTuple.1 - The starting block number (inclusive) from which to query.
+         * @param paramsTuple.2 - The maximum number of events to return.
+         * @returns A promise that resolves to an array of decoded public event data. The specific type
+         *          of the event data depends on the `eventMetadata`.
+         *          Type defined by {@link AztecWalletMethodMap.aztec_getPublicEvents.result}.
+         * @throws {Error} If any required parameters are missing or invalid, though type checking
+         *                 and serializer validation should catch this earlier.
+         */
+        aztec_getPublicEvents: async (ctx, paramsTuple) => {
+            const [eventMetadata, from, limit] = paramsTuple;
+            logger.debug(`[HANDLER] aztec_getPublicEvents: from = ${from}, limit = ${limit}`);
+            // All parameters are mandatory in the tuple type definition.
+            if (!eventMetadata || from === undefined || limit === undefined) {
+                throw new Error('Invalid parameters received in tuple for aztec_getPublicEvents');
+            }
+            return await ctx.pxe.getPublicEvents(eventMetadata, from, limit);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvd2FsbGV0L2hhbmRsZXJzL2V2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVyRCxNQUFNLE1BQU0sR0FBRyxZQUFZLENBQUMsd0JBQXdCLENBQUMsQ0FBQztBQUV0RDs7Ozs7Ozs7Ozs7O0dBWUc7QUFDSCxNQUFNLFVBQVUsbUJBQW1CO0lBQ2pDLE9BQU87UUFDTDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O1dBcUJHO1FBQ0gsc0JBQXNCLEVBQUUsS0FBSyxFQUMzQixHQUF3QixFQUN4QixXQUFxRSxFQUNGLEVBQUU7WUFDckUsTUFBTSxDQUFDLGVBQWUsRUFBRSxhQUFhLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxVQUFVLENBQUMsR0FBRyxXQUFXLENBQUM7WUFDbEYsTUFBTSxDQUFDLEtBQUssQ0FDVix1REFBdUQsZUFBZSxFQUFFLFFBQVEsRUFBRSxZQUFZLElBQUksaUJBQWlCLFNBQVMsRUFBRSxDQUMvSCxDQUFDO1lBQ0YsNkRBQTZEO1lBQzdELDhGQUE4RjtZQUM5RixJQUNFLENBQUMsZUFBZTtnQkFDaEIsQ0FBQyxhQUFhO2dCQUNkLElBQUksS0FBSyxTQUFTO2dCQUNsQixTQUFTLEtBQUssU0FBUztnQkFDdkIsQ0FBQyxVQUFVLEVBQ1gsQ0FBQztnQkFDRCxNQUFNLElBQUksS0FBSyxDQUFDLGlFQUFpRSxDQUFDLENBQUM7WUFDckYsQ0FBQztZQUNELE9BQU8sTUFBTSxHQUFHLENBQUMsR0FBRyxDQUFDLGdCQUFnQixDQUFDLGVBQWUsRUFBRSxhQUFhLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUNyRyxDQUFDO1FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7V0FtQkc7UUFDSCxxQkFBcUIsRUFBRSxLQUFLLEVBQzFCLEdBQXdCLEVBQ3hCLFdBQW9FLEVBQ0YsRUFBRTtZQUNwRSxNQUFNLENBQUMsYUFBYSxFQUFFLElBQUksRUFBRSxLQUFLLENBQUMsR0FBRyxXQUFXLENBQUM7WUFDakQsTUFBTSxDQUFDLEtBQUssQ0FBQywyQ0FBMkMsSUFBSSxhQUFhLEtBQUssRUFBRSxDQUFDLENBQUM7WUFDbEYsNkRBQTZEO1lBQzdELElBQUksQ0FBQyxhQUFhLElBQUksSUFBSSxLQUFLLFNBQVMsSUFBSSxLQUFLLEtBQUssU0FBUyxFQUFFLENBQUM7Z0JBQ2hFLE1BQU0sSUFBSSxLQUFLLENBQUMsZ0VBQWdFLENBQUMsQ0FBQztZQUNwRixDQUFDO1lBQ0QsT0FBTyxNQUFNLEdBQUcsQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLGFBQWEsRUFBRSxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDbkUsQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDIn0=