@walletmesh/aztec-rpc-wallet 0.1.0

package/dist/contractArtifactCache.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @module contractArtifactCache
+ *
+ * This module provides caching functionality for Aztec contract artifacts.
+ * It helps improve performance by avoiding repeated fetches of the same contract artifacts.
+ */
+import type { AztecAddress, ContractArtifact, Wallet } from '@aztec/aztec.js';
+/**
+ * Caches contract artifacts to optimize contract interactions.
+ *
+ * This class maintains an in-memory cache of contract artifacts indexed by contract address.
+ * When a contract artifact is requested:
+ * 1. First checks the cache for an existing artifact
+ * 2. If not found, fetches the contract instance and its artifact from the wallet
+ * 3. Stores the artifact in the cache for future use
+ * 4. Returns the artifact to the caller
+ *
+ * This caching mechanism helps reduce:
+ * - Network requests to fetch contract data
+ * - Processing overhead of parsing contract artifacts
+ * - Memory usage by reusing existing artifacts
+ */
+export declare class ContractArtifactCache {
+    /** Map of contract addresses to their artifacts */
+    private cache;
+    /** Reference to the wallet instance for fetching contract data */
+    private wallet;
+    /**
+     * Creates a new ContractArtifactCache instance.
+     * @param wallet - Wallet instance used to fetch contract data when cache misses occur
+     */
+    constructor(wallet: Wallet);
+    /**
+     * Retrieves the contract artifact for a given contract address.
+     * First checks the cache, then falls back to fetching from the wallet if needed.
+     *
+     * The process:
+     * 1. Check if artifact exists in cache
+     * 2. If not, get contract instance from wallet
+     * 3. Use instance to get contract class ID
+     * 4. Fetch artifact using class ID
+     * 5. Cache the artifact for future use
+     *
+     * @param contractAddress - The contract address to retrieve the artifact for
+     * @returns Promise resolving to the contract artifact
+     * @throws {AztecWalletError} If contract instance or class not registered
+     */
+    getContractArtifact(contractAddress: AztecAddress): Promise<ContractArtifact>;
+}
+//# sourceMappingURL=contractArtifactCache.d.ts.map

package/dist/contractArtifactCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contractArtifactCache.d.ts","sourceRoot":"","sources":["../src/contractArtifactCache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAI9E;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAqB;IAChC,mDAAmD;IACnD,OAAO,CAAC,KAAK,CAAuC;IACpD,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAS;IAEvB;;;OAGG;gBACS,MAAM,EAAE,MAAM;IAI1B;;;;;;;;;;;;;;OAcG;IACU,mBAAmB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAmB3F"}

package/dist/contractArtifactCache.js

@@ -0,0 +1,66 @@
+/**
+ * @module contractArtifactCache
+ *
+ * This module provides caching functionality for Aztec contract artifacts.
+ * It helps improve performance by avoiding repeated fetches of the same contract artifacts.
+ */
+import { AztecWalletError } from './errors.js';
+/**
+ * Caches contract artifacts to optimize contract interactions.
+ *
+ * This class maintains an in-memory cache of contract artifacts indexed by contract address.
+ * When a contract artifact is requested:
+ * 1. First checks the cache for an existing artifact
+ * 2. If not found, fetches the contract instance and its artifact from the wallet
+ * 3. Stores the artifact in the cache for future use
+ * 4. Returns the artifact to the caller
+ *
+ * This caching mechanism helps reduce:
+ * - Network requests to fetch contract data
+ * - Processing overhead of parsing contract artifacts
+ * - Memory usage by reusing existing artifacts
+ */
+export class ContractArtifactCache {
+    /**
+     * Creates a new ContractArtifactCache instance.
+     * @param wallet - Wallet instance used to fetch contract data when cache misses occur
+     */
+    constructor(wallet) {
+        /** Map of contract addresses to their artifacts */
+        this.cache = new Map();
+        this.wallet = wallet;
+    }
+    /**
+     * Retrieves the contract artifact for a given contract address.
+     * First checks the cache, then falls back to fetching from the wallet if needed.
+     *
+     * The process:
+     * 1. Check if artifact exists in cache
+     * 2. If not, get contract instance from wallet
+     * 3. Use instance to get contract class ID
+     * 4. Fetch artifact using class ID
+     * 5. Cache the artifact for future use
+     *
+     * @param contractAddress - The contract address to retrieve the artifact for
+     * @returns Promise resolving to the contract artifact
+     * @throws {AztecWalletError} If contract instance or class not registered
+     */
+    async getContractArtifact(contractAddress) {
+        const addressStr = contractAddress.toString();
+        const cached = this.cache.get(addressStr);
+        if (cached) {
+            return cached;
+        }
+        const contract = await this.wallet.getContractInstance(contractAddress);
+        if (!contract) {
+            throw new AztecWalletError('contractInstanceNotRegistered', addressStr);
+        }
+        const artifact = await this.wallet.getContractArtifact(contract.contractClassId);
+        if (!artifact) {
+            throw new AztecWalletError('contractClassNotRegistered', contract.contractClassId.toString());
+        }
+        this.cache.set(addressStr, artifact);
+        return artifact;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RBcnRpZmFjdENhY2hlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnRyYWN0QXJ0aWZhY3RDYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUlILE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUUvQzs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQU0sT0FBTyxxQkFBcUI7SUFNaEM7OztPQUdHO0lBQ0gsWUFBWSxNQUFjO1FBVDFCLG1EQUFtRDtRQUMzQyxVQUFLLEdBQUcsSUFBSSxHQUFHLEVBQTRCLENBQUM7UUFTbEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7SUFDdkIsQ0FBQztJQUVEOzs7Ozs7Ozs7Ozs7OztPQWNHO0lBQ0ksS0FBSyxDQUFDLG1CQUFtQixDQUFDLGVBQTZCO1FBQzVELE1BQU0sVUFBVSxHQUFHLGVBQWUsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUM5QyxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUMxQyxJQUFJLE1BQU0sRUFBRSxDQUFDO1lBQ1gsT0FBTyxNQUFNLENBQUM7UUFDaEIsQ0FBQztRQUVELE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUN4RSxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDZCxNQUFNLElBQUksZ0JBQWdCLENBQUMsK0JBQStCLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDMUUsQ0FBQztRQUNELE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDLENBQUM7UUFDakYsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ2QsTUFBTSxJQUFJLGdCQUFnQixDQUFDLDRCQUE0QixFQUFFLFFBQVEsQ0FBQyxlQUFlLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztRQUNoRyxDQUFDO1FBRUQsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQ3JDLE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRiJ9

package/dist/errors.d.ts

@@ -0,0 +1,50 @@
+import { JSONRPCError } from '@walletmesh/jsonrpc';
+/**
+ * Enum of available Aztec Wallet RPC error types.
+ * @public
+ */
+export declare const AztecWalletErrorType: {
+    readonly unknownInternalError: "unknownInternalError";
+    readonly refused: "refused";
+    readonly walletNotConnected: "walletNotConnected";
+    readonly contractInstanceNotRegistered: "contractInstanceNotRegistered";
+    readonly contractClassNotRegistered: "contractClassNotRegistered";
+    readonly senderNotRegistered: "senderNotRegistered";
+    readonly invalidResponse: "invalidResponse";
+    readonly notConnected: "notConnected";
+    readonly chainNotSupported: "chainNotSupported";
+    readonly invalidRequest: "invalidRequest";
+    readonly invalidParams: "invalidParams";
+    readonly permissionDenied: "permissionDenied";
+    readonly sessionNotFound: "sessionNotFound";
+    readonly sessionExpired: "sessionExpired";
+    readonly transactionNotFound: "transactionNotFound";
+    readonly blockNotFound: "blockNotFound";
+    readonly authWitnessNotFound: "authWitnessNotFound";
+};
+/**
+ * Type representing valid Aztec Wallet RPC error types.
+ * @public
+ */
+export type AztecWalletErrorType = (typeof AztecWalletErrorType)[keyof typeof AztecWalletErrorType];
+/**
+ * Map of error codes and messages for Aztec Wallet RPC errors.
+ * @public
+ */
+export declare const AztecWalletErrorMap: Record<AztecWalletErrorType, {
+    code: number;
+    message: string;
+}>;
+/**
+ * Custom error class for Aztec Wallet RPC errors.
+ * @public
+ */
+export declare class AztecWalletError extends JSONRPCError {
+    /**
+     * Creates a new AztecWalletError.
+     * @param err - The error type from AztecWalletErrorMap
+     * @param data - Optional additional error data
+     */
+    constructor(err: AztecWalletErrorType, data?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;CAkBvB,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEpG;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,oBAAoB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAkB/F,CAAC;AAEF;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD;;;;OAIG;gBACS,GAAG,EAAE,oBAAoB,EAAE,IAAI,CAAC,EAAE,MAAM;CAGrD"}

package/dist/errors.js

@@ -0,0 +1,62 @@
+import { JSONRPCError } from '@walletmesh/jsonrpc';
+/**
+ * Enum of available Aztec Wallet RPC error types.
+ * @public
+ */
+export const AztecWalletErrorType = {
+    unknownInternalError: 'unknownInternalError',
+    refused: 'refused',
+    walletNotConnected: 'walletNotConnected',
+    contractInstanceNotRegistered: 'contractInstanceNotRegistered',
+    contractClassNotRegistered: 'contractClassNotRegistered',
+    senderNotRegistered: 'senderNotRegistered',
+    invalidResponse: 'invalidResponse',
+    notConnected: 'notConnected',
+    chainNotSupported: 'chainNotSupported',
+    invalidRequest: 'invalidRequest',
+    invalidParams: 'invalidParams',
+    permissionDenied: 'permissionDenied',
+    sessionNotFound: 'sessionNotFound',
+    sessionExpired: 'sessionExpired',
+    transactionNotFound: 'transactionNotFound',
+    blockNotFound: 'blockNotFound',
+    authWitnessNotFound: 'authWitnessNotFound',
+};
+/**
+ * Map of error codes and messages for Aztec Wallet RPC errors.
+ * @public
+ */
+export const AztecWalletErrorMap = {
+    unknownInternalError: { code: -32000, message: 'Unknown internal error' },
+    refused: { code: -32001, message: 'User refused transaction' },
+    walletNotConnected: { code: -32002, message: 'Wallet not connected' },
+    contractInstanceNotRegistered: { code: -32003, message: 'Contract instance not registered' },
+    contractClassNotRegistered: { code: -32004, message: 'Contract class not registered' },
+    senderNotRegistered: { code: -32005, message: 'Sender not registered' },
+    invalidResponse: { code: -32006, message: 'Invalid response format' },
+    notConnected: { code: -32007, message: 'Not connected to any chain' },
+    chainNotSupported: { code: -32008, message: 'Chain not supported' },
+    invalidRequest: { code: -32009, message: 'Invalid request format' },
+    invalidParams: { code: -32010, message: 'Invalid parameters' },
+    permissionDenied: { code: -32011, message: 'Permission denied' },
+    sessionNotFound: { code: -32012, message: 'Session not found' },
+    sessionExpired: { code: -32013, message: 'Session expired' },
+    transactionNotFound: { code: -32014, message: 'Transaction not found' },
+    blockNotFound: { code: -32015, message: 'Block not found' },
+    authWitnessNotFound: { code: -32016, message: 'Authorization witness not found' },
+};
+/**
+ * Custom error class for Aztec Wallet RPC errors.
+ * @public
+ */
+export class AztecWalletError extends JSONRPCError {
+    /**
+     * Creates a new AztecWalletError.
+     * @param err - The error type from AztecWalletErrorMap
+     * @param data - Optional additional error data
+     */
+    constructor(err, data) {
+        super(AztecWalletErrorMap[err].code, AztecWalletErrorMap[err].message, data);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/handlers/aztecAccountWallet.d.ts

@@ -0,0 +1,4 @@
+import type { AztecWalletContext, AztecWalletMethodMap } from '../types.js';
+export declare const AZTEC_WALLET_METHODS: (keyof AztecWalletMethodMap)[];
+export declare function aztecWalletHandler<M extends keyof AztecWalletMethodMap>(context: AztecWalletContext, method: M, params: AztecWalletMethodMap[M]['params']): Promise<AztecWalletMethodMap[M]['result']>;
+//# sourceMappingURL=aztecAccountWallet.d.ts.map

package/dist/handlers/aztecAccountWallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aztecAccountWallet.d.ts","sourceRoot":"","sources":["../../src/handlers/aztecAccountWallet.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAE5E,eAAO,MAAM,oBAAoB,EAAE,CAAC,MAAM,oBAAoB,CAAC,EA8CrD,CAAC;AAwVX,wBAAsB,kBAAkB,CAAC,CAAC,SAAS,MAAM,oBAAoB,EAC3E,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GACxC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAkM5C"}

package/dist/handlers/aztecAccountWallet.js

@@ -0,0 +1,329 @@
+import { AztecWalletError } from '../errors.js';
+export const AZTEC_WALLET_METHODS = [
+    'aztec_getBlock',
+    'aztec_getBlockNumber',
+    'aztec_getChainId',
+    'aztec_getVersion',
+    'aztec_getNodeInfo',
+    'aztec_getCurrentBaseFees',
+    'aztec_setScopes',
+    'aztec_getScopes',
+    'aztec_isL1ToL2MessageSynced',
+    'aztec_getL1ToL2MembershipWitness',
+    'aztec_addCapsule',
+    'aztec_getAddress',
+    'aztec_getCompleteAddress',
+    'aztec_registerAccount',
+    'aztec_getRegisteredAccounts',
+    'aztec_addAuthWitness',
+    'aztec_getAuthWitness',
+    'aztec_createAuthWit',
+    'aztec_registerSender',
+    'aztec_getSenders',
+    'aztec_removeSender',
+    'aztec_getContracts',
+    'aztec_getContractInstance',
+    'aztec_getContractClass',
+    'aztec_getContractArtifact',
+    'aztec_isContractClassPubliclyRegistered',
+    'aztec_isContractPubliclyDeployed',
+    'aztec_isContractInitialized',
+    'aztec_registerContract',
+    'aztec_registerContractClass',
+    'aztec_getPublicStorageAt',
+    'aztec_createTxExecutionRequest',
+    'aztec_proveTx',
+    'aztec_sendTx',
+    'aztec_getTxEffect',
+    'aztec_getTxReceipt',
+    'aztec_simulateTx',
+    'aztec_simulateUnconstrained',
+    'aztec_getIncomingNotes',
+    'aztec_addNote',
+    'aztec_addNullifiedNote',
+    'aztec_getUnencryptedLogs',
+    'aztec_getContractClassLogs',
+    'aztec_getEncryptedEvents',
+    'aztec_getUnencryptedEvents',
+];
+// Handler functions with proper type safety
+async function handleGetBlock(wallet, params) {
+    const block = await wallet.getBlock(params.number);
+    if (!block)
+        throw new AztecWalletError('blockNotFound', 'aztec_getBlock');
+    return block;
+}
+async function handleGetBlockNumber(wallet) {
+    return await wallet.getBlockNumber();
+}
+async function handleGetChainId(wallet) {
+    return Number(wallet.getChainId());
+}
+async function handleGetVersion(wallet) {
+    return Number(wallet.getVersion());
+}
+async function handleGetNodeInfo(wallet) {
+    return await wallet.getNodeInfo();
+}
+async function handleGetCurrentBaseFees(wallet) {
+    return await wallet.getCurrentBaseFees();
+}
+async function handleSetScopes(wallet, params) {
+    await wallet.setScopes(params.scopes);
+    return true;
+}
+async function handleGetScopes(wallet) {
+    const scopes = await wallet.getScopes();
+    return scopes ?? [];
+}
+async function handleAddCapsule(wallet, params) {
+    await wallet.addCapsule(params.capsule);
+    return true;
+}
+async function handleGetAddress(wallet) {
+    return wallet.getAddress();
+}
+async function handleGetCompleteAddress(wallet) {
+    return wallet.getCompleteAddress();
+}
+async function handleRegisterAccount(wallet, params) {
+    return await wallet.registerAccount(params.secretKey, params.partialAddress);
+}
+async function handleGetRegisteredAccounts(wallet) {
+    return await wallet.getRegisteredAccounts();
+}
+async function handleRegisterSender(wallet, params) {
+    return await wallet.registerSender(params.sender);
+}
+async function handleGetSenders(wallet) {
+    return await wallet.getSenders();
+}
+async function handleRemoveSender(wallet, params) {
+    await wallet.removeSender(params.sender);
+    return true;
+}
+async function handleAddAuthWitness(wallet, params) {
+    await wallet.addAuthWitness(params.authWitness);
+    return true;
+}
+async function handleGetAuthWitness(wallet, params) {
+    const witness = await wallet.getAuthWitness(params.messageHash);
+    if (!witness)
+        throw new AztecWalletError('authWitnessNotFound', 'aztec_getAuthWitness');
+    return witness;
+}
+async function handleCreateAuthWit(wallet, params) {
+    return await wallet.createAuthWit(params.intent);
+}
+async function handleL1ToL2MessageSynced(wallet, params) {
+    return await wallet.isL1ToL2MessageSynced(params.l1ToL2Message);
+}
+async function handleGetContracts(wallet) {
+    return await wallet.getContracts();
+}
+async function handleGetContractInstance(wallet, params) {
+    const instance = await wallet.getContractInstance(params.address);
+    if (!instance)
+        throw new AztecWalletError('contractInstanceNotRegistered', 'aztec_getContractInstance');
+    return instance;
+}
+async function handleGetContractClass(wallet, params) {
+    const contractClass = await wallet.getContractClass(params.id);
+    if (!contractClass)
+        throw new AztecWalletError('contractClassNotRegistered', 'aztec_getContractClass');
+    return contractClass;
+}
+async function handleGetContractArtifact(wallet, params) {
+    const artifact = await wallet.getContractArtifact(params.id);
+    if (!artifact)
+        throw new AztecWalletError('contractClassNotRegistered', 'aztec_getContractArtifact');
+    return artifact;
+}
+async function handleIsContractClassPubliclyRegistered(wallet, params) {
+    return await wallet.isContractClassPubliclyRegistered(params.id);
+}
+async function handleIsContractPubliclyDeployed(wallet, params) {
+    return await wallet.isContractPubliclyDeployed(params.address);
+}
+async function handleIsContractInitialized(wallet, params) {
+    return await wallet.isContractInitialized(params.address);
+}
+async function handleRegisterContract(wallet, params) {
+    const { instance, artifact } = params;
+    await wallet.registerContract({ instance, artifact });
+    return true;
+}
+async function handleRegisterContractClass(wallet, params) {
+    const { artifact } = params;
+    await wallet.registerContractClass(artifact);
+    return true;
+}
+async function handleGetTxReceipt(wallet, params) {
+    const receipt = await wallet.getTxReceipt(params.txHash);
+    if (!receipt)
+        throw new AztecWalletError('transactionNotFound', 'aztec_getTxReceipt');
+    return receipt;
+}
+async function handleSimulateTx(wallet, params) {
+    const { txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile } = params;
+    return await wallet.simulateTx(txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile);
+}
+async function handleSimulateUnconstrained(wallet, params) {
+    const { functionName, args, to, from } = params;
+    return await wallet.simulateUnconstrained(functionName, args, to, from);
+}
+async function handleCreateTxExecutionRequest(wallet, params) {
+    return await wallet.createTxExecutionRequest(params.exec);
+}
+async function handleProveTx(wallet, params) {
+    return await wallet.proveTx(params.txRequest, params.privateExecutionResult);
+}
+async function handleSendTx(wallet, params) {
+    return await wallet.sendTx(params.tx);
+}
+async function handleGetTxEffect(wallet, params) {
+    const effect = await wallet.getTxEffect(params.txHash);
+    if (!effect)
+        throw new AztecWalletError('transactionNotFound', 'aztec_getTxEffect');
+    return effect;
+}
+async function handleGetPublicStorageAt(wallet, params) {
+    return await wallet.getPublicStorageAt(params.contract, params.storageSlot);
+}
+async function handleGetIncomingNotes(wallet, params) {
+    return await wallet.getIncomingNotes(params.filter);
+}
+async function handleAddNote(wallet, params) {
+    await wallet.addNote(params.note);
+    return true;
+}
+async function handleAddNullifiedNote(wallet, params) {
+    await wallet.addNullifiedNote(params.note);
+    return true;
+}
+async function handleGetUnencryptedLogs(wallet, params) {
+    return await wallet.getUnencryptedLogs(params.filter);
+}
+async function handleGetContractClassLogs(wallet, params) {
+    return await wallet.getContractClassLogs(params.filter);
+}
+async function handleGetEncryptedEvents(wallet, params) {
+    const { event, from, limit, vpks } = params;
+    return await wallet.getEncryptedEvents(event, from, limit, vpks);
+}
+async function handleGetUnencryptedEvents(wallet, params) {
+    const { event, from, limit } = params;
+    return await wallet.getUnencryptedEvents(event, from, limit);
+}
+async function handleL1ToL2MembershipWitness(wallet, params) {
+    const { contractAddress, messageHash, secret } = params;
+    return await wallet.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
+}
+export async function aztecWalletHandler(context, method, params) {
+    switch (method) {
+        // Chain methods
+        case 'aztec_getBlock':
+            return handleGetBlock(context.wallet, params);
+        case 'aztec_getBlockNumber':
+            return handleGetBlockNumber(context.wallet);
+        case 'aztec_getChainId':
+            return handleGetChainId(context.wallet);
+        case 'aztec_getVersion':
+            return handleGetVersion(context.wallet);
+        case 'aztec_getNodeInfo':
+            return handleGetNodeInfo(context.wallet);
+        case 'aztec_getCurrentBaseFees':
+            return handleGetCurrentBaseFees(context.wallet);
+        // Scopes methods
+        case 'aztec_setScopes':
+            return handleSetScopes(context.wallet, params);
+        case 'aztec_getScopes':
+            return handleGetScopes(context.wallet);
+        // L1->L2 Messages methods
+        case 'aztec_isL1ToL2MessageSynced':
+            return handleL1ToL2MessageSynced(context.wallet, params);
+        case 'aztec_getL1ToL2MembershipWitness':
+            return handleL1ToL2MembershipWitness(context.wallet, params);
+        // Capsules methods
+        case 'aztec_addCapsule':
+            return handleAddCapsule(context.wallet, params);
+        // Accounts methods
+        case 'aztec_getAddress':
+            return handleGetAddress(context.wallet);
+        case 'aztec_getCompleteAddress':
+            return handleGetCompleteAddress(context.wallet);
+        case 'aztec_registerAccount':
+            return handleRegisterAccount(context.wallet, params);
+        case 'aztec_getRegisteredAccounts':
+            return handleGetRegisteredAccounts(context.wallet);
+        // AuthWitness methods
+        case 'aztec_addAuthWitness':
+            return handleAddAuthWitness(context.wallet, params);
+        case 'aztec_getAuthWitness':
+            return handleGetAuthWitness(context.wallet, params);
+        case 'aztec_createAuthWit':
+            return handleCreateAuthWit(context.wallet, params);
+        // Senders methods
+        case 'aztec_registerSender':
+            return handleRegisterSender(context.wallet, params);
+        case 'aztec_getSenders':
+            return handleGetSenders(context.wallet);
+        case 'aztec_removeSender':
+            return handleRemoveSender(context.wallet, params);
+        // Contracts methods
+        case 'aztec_getContracts':
+            return handleGetContracts(context.wallet);
+        case 'aztec_getContractInstance':
+            return handleGetContractInstance(context.wallet, params);
+        case 'aztec_getContractClass':
+            return handleGetContractClass(context.wallet, params);
+        case 'aztec_getContractArtifact':
+            return handleGetContractArtifact(context.wallet, params);
+        case 'aztec_isContractClassPubliclyRegistered':
+            return handleIsContractClassPubliclyRegistered(context.wallet, params);
+        case 'aztec_isContractPubliclyDeployed':
+            return handleIsContractPubliclyDeployed(context.wallet, params);
+        case 'aztec_isContractInitialized':
+            return handleIsContractInitialized(context.wallet, params);
+        case 'aztec_registerContract':
+            return handleRegisterContract(context.wallet, params);
+        case 'aztec_registerContractClass':
+            return handleRegisterContractClass(context.wallet, params);
+        case 'aztec_getPublicStorageAt':
+            return handleGetPublicStorageAt(context.wallet, params);
+        // Transactions methods
+        case 'aztec_createTxExecutionRequest':
+            return handleCreateTxExecutionRequest(context.wallet, params);
+        case 'aztec_proveTx':
+            return handleProveTx(context.wallet, params);
+        case 'aztec_sendTx':
+            return handleSendTx(context.wallet, params);
+        case 'aztec_getTxEffect':
+            return handleGetTxEffect(context.wallet, params);
+        case 'aztec_getTxReceipt':
+            return handleGetTxReceipt(context.wallet, params);
+        case 'aztec_simulateTx':
+            return handleSimulateTx(context.wallet, params);
+        case 'aztec_simulateUnconstrained':
+            return handleSimulateUnconstrained(context.wallet, params);
+        // Notes methods
+        case 'aztec_getIncomingNotes':
+            return handleGetIncomingNotes(context.wallet, params);
+        case 'aztec_addNote':
+            return handleAddNote(context.wallet, params);
+        case 'aztec_addNullifiedNote':
+            return handleAddNullifiedNote(context.wallet, params);
+        // Logs methods
+        case 'aztec_getUnencryptedLogs':
+            return handleGetUnencryptedLogs(context.wallet, params);
+        case 'aztec_getContractClassLogs':
+            return handleGetContractClassLogs(context.wallet, params);
+        case 'aztec_getEncryptedEvents':
+            return handleGetEncryptedEvents(context.wallet, params);
+        case 'aztec_getUnencryptedEvents':
+            return handleGetUnencryptedEvents(context.wallet, params);
+        default:
+            throw new AztecWalletError('invalidRequest', `Method not supported: ${String(method)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aztecAccountWallet.js","sourceRoot":"","sources":["../../src/handlers/aztecAccountWallet.ts"],"names":[],"mappings":"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"}

package/dist/handlers/transactions.d.ts

@@ -0,0 +1,21 @@
+import type { AztecWalletContext, TransactionFunctionCall, TransactionParams } from '../types.js';
+/**
+ * Handles the 'aztec_sendTransaction' JSON-RPC method.
+ * Sends transactions to the Aztec network and returns the transaction hash.
+ * @param params - The transaction parameters
+ * @param params.functionCalls - Array of function calls to execute
+ * @param params.authwits - Optional array of authorization witnesses for the transaction
+ * @returns A Promise that resolves to the transaction hash string
+ */
+export declare function sendTransaction(context: AztecWalletContext, params: TransactionParams): Promise<string>;
+/**
+ * Handles the 'aztec_simulateTransaction' JSON-RPC method.
+ * Simulates a transaction without submitting it to the network.
+ * @param params - The transaction parameters to simulate
+ * @param params.contractAddress - The target contract address
+ * @param params.functionName - The contract function to call
+ * @param params.args - The function arguments
+ * @returns A Promise that resolves to the simulation result
+ */
+export declare function simulateTransaction(context: AztecWalletContext, params: TransactionFunctionCall): Promise<unknown>;
+//# sourceMappingURL=transactions.d.ts.map

package/dist/handlers/transactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.ts","sourceRoot":"","sources":["../../src/handlers/transactions.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGlG;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,MAAM,CAAC,CA0CjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,OAAO,CAAC,CA4BlB"}