@walletmesh/aztec-rpc-wallet 0.3.1 → 0.4.0

package/dist/client/aztec-router-provider.d.ts

@@ -0,0 +1,58 @@
+import { WalletRouterProvider } from '@walletmesh/router';
+import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
+/**
+ * An extended {@link WalletRouterProvider} specifically for Aztec network interactions.
+ *
+ * This class automatically registers all necessary Aztec-specific type serializers
+ * (e.g., for `AztecAddress`, `Fr`, `TxExecutionRequest`) upon instantiation.
+ * This ensures that when dApps communicate with an Aztec wallet via this provider,
+ * all Aztec types are correctly serialized for JSON-RPC transport and deserialized
+ * back into their proper object instances on receipt.
+ *
+ * It simplifies the setup for dApp developers, as they do not need to manually
+ * register serializers for Aztec types.
+ *
+ * @example
+ * ```typescript
+ * import { AztecRouterProvider, createAztecWallet } from '@walletmesh/aztec-rpc-wallet';
+ * import { MyCustomTransport } from './my-custom-transport'; // Assuming a custom transport
+ *
+ * // 1. Create a JSON-RPC transport
+ * const transport = new MyCustomTransport();
+ *
+ * // 2. Create the AztecRouterProvider instance
+ * const provider = new AztecRouterProvider(transport);
+ *
+ * // 3. Connect to the Aztec chain (e.g., testnet) and request permissions
+ * await provider.connect({
+ *   'aztec:testnet': ['aztec_getAddress', 'aztec_sendTx']
+ * });
+ *
+ * // 4. Create an AztecDappWallet instance using the provider
+ * const wallet = await createAztecWallet(provider, 'aztec:testnet');
+ *
+ * // Now, calls made through 'wallet' will automatically handle Aztec type serialization:
+ * const address = await wallet.getAddress(); // AztecAddress instance
+ * // const txRequest = ...;
+ * // const txHash = await wallet.sendTx(await wallet.proveTx(txRequest)); // Tx, TxHash instances
+ * ```
+ *
+ * @see {@link WalletRouterProvider} for the base class functionality.
+ * @see {@link registerAztecSerializers} for the underlying serializer registration.
+ * @see {@link AztecDappWallet} which is typically used with this provider.
+ */
+export declare class AztecRouterProvider extends WalletRouterProvider {
+    /**
+     * Constructs an instance of `AztecRouterProvider`.
+     *
+     * Upon construction, it immediately registers all Aztec-specific serializers
+     * with the underlying JSON-RPC node managed by the `WalletRouterProvider`.
+     *
+     * @param transport - The {@link JSONRPCTransport} instance to be used for
+     *                    communication between the dApp and the WalletRouter.
+     * @param context - Optional context object that can be passed to the
+     *                  `WalletRouterProvider` constructor.
+     */
+    constructor(transport: JSONRPCTransport, context?: Record<string, unknown>);
+}
+//# sourceMappingURL=aztec-router-provider.d.ts.map

package/dist/client/aztec-router-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aztec-router-provider.d.ts","sourceRoot":"","sources":["../../src/client/aztec-router-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,mBAAoB,SAAQ,oBAAoB;IAC3D;;;;;;;;;;OAUG;gBACS,SAAS,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAM3E"}

package/dist/client/aztec-router-provider.js

@@ -0,0 +1,62 @@
+import { WalletRouterProvider } from '@walletmesh/router';
+import { registerAztecSerializers } from './register-serializers.js';
+/**
+ * An extended {@link WalletRouterProvider} specifically for Aztec network interactions.
+ *
+ * This class automatically registers all necessary Aztec-specific type serializers
+ * (e.g., for `AztecAddress`, `Fr`, `TxExecutionRequest`) upon instantiation.
+ * This ensures that when dApps communicate with an Aztec wallet via this provider,
+ * all Aztec types are correctly serialized for JSON-RPC transport and deserialized
+ * back into their proper object instances on receipt.
+ *
+ * It simplifies the setup for dApp developers, as they do not need to manually
+ * register serializers for Aztec types.
+ *
+ * @example
+ * ```typescript
+ * import { AztecRouterProvider, createAztecWallet } from '@walletmesh/aztec-rpc-wallet';
+ * import { MyCustomTransport } from './my-custom-transport'; // Assuming a custom transport
+ *
+ * // 1. Create a JSON-RPC transport
+ * const transport = new MyCustomTransport();
+ *
+ * // 2. Create the AztecRouterProvider instance
+ * const provider = new AztecRouterProvider(transport);
+ *
+ * // 3. Connect to the Aztec chain (e.g., testnet) and request permissions
+ * await provider.connect({
+ *   'aztec:testnet': ['aztec_getAddress', 'aztec_sendTx']
+ * });
+ *
+ * // 4. Create an AztecDappWallet instance using the provider
+ * const wallet = await createAztecWallet(provider, 'aztec:testnet');
+ *
+ * // Now, calls made through 'wallet' will automatically handle Aztec type serialization:
+ * const address = await wallet.getAddress(); // AztecAddress instance
+ * // const txRequest = ...;
+ * // const txHash = await wallet.sendTx(await wallet.proveTx(txRequest)); // Tx, TxHash instances
+ * ```
+ *
+ * @see {@link WalletRouterProvider} for the base class functionality.
+ * @see {@link registerAztecSerializers} for the underlying serializer registration.
+ * @see {@link AztecDappWallet} which is typically used with this provider.
+ */
+export class AztecRouterProvider extends WalletRouterProvider {
+    /**
+     * Constructs an instance of `AztecRouterProvider`.
+     *
+     * Upon construction, it immediately registers all Aztec-specific serializers
+     * with the underlying JSON-RPC node managed by the `WalletRouterProvider`.
+     *
+     * @param transport - The {@link JSONRPCTransport} instance to be used for
+     *                    communication between the dApp and the WalletRouter.
+     * @param context - Optional context object that can be passed to the
+     *                  `WalletRouterProvider` constructor.
+     */
+    constructor(transport, context) {
+        super(transport, context);
+        // Register all Aztec serializers on this provider instance
+        registerAztecSerializers(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXp0ZWMtcm91dGVyLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NsaWVudC9henRlYy1yb3V0ZXItcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFMUQsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFckU7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F3Q0c7QUFDSCxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsb0JBQW9CO0lBQzNEOzs7Ozs7Ozs7O09BVUc7SUFDSCxZQUFZLFNBQTJCLEVBQUUsT0FBaUM7UUFDeEUsS0FBSyxDQUFDLFNBQVMsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUUxQiwyREFBMkQ7UUFDM0Qsd0JBQXdCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDakMsQ0FBQztDQUNGIn0=

package/dist/client/helpers.d.ts

@@ -0,0 +1,44 @@
+import type { AztecChainId } from '../types.js';
+import type { AztecDappWallet } from './aztec-dapp-wallet.js';
+import type { AztecRouterProvider } from './aztec-router-provider.js';
+/**
+ * A comprehensive list of all JSON-RPC methods supported by the Aztec RPC wallet.
+ * This array includes standard Aztec wallet methods as well as WalletMesh-specific extensions (prefixed with `wm_`).
+ * It can be used when establishing a connection to request permissions for all available functionalities.
+ *
+ * @see {@link AztecWalletMethodMap} for detailed type information on each method.
+ * @see {@link connectAztec} and {@link connectAztecWithWallet} which use this list by default.
+ */
+export declare const ALL_AZTEC_METHODS: readonly ["aztec_getAddress", "aztec_getCompleteAddress", "aztec_getChainId", "aztec_getVersion", "aztec_sendTx", "aztec_getTxReceipt", "aztec_simulateTx", "aztec_getNodeInfo", "aztec_getBlockNumber", "aztec_getCurrentBaseFees", "aztec_registerSender", "aztec_getSenders", "aztec_removeSender", "aztec_registerContract", "aztec_registerContractClass", "aztec_getContractMetadata", "aztec_getContractClassMetadata", "aztec_proveTx", "aztec_profileTx", "aztec_simulateUtility", "aztec_getPrivateEvents", "aztec_getPublicEvents", "aztec_getPXEInfo", "aztec_getBlock", "aztec_createAuthWit", "aztec_wmDeployContract", "aztec_wmExecuteTx", "aztec_wmSimulateTx"];
+/**
+ * Establishes a connection to an Aztec wallet service and creates an initialized {@link AztecDappWallet} instance.
+ * This function requests permissions for the specified methods on the given Aztec chain,
+ * then instantiates and initializes the wallet.
+ * Initialization includes fetching and caching essential data like the wallet address and chain ID.
+ *
+ * By default, it requests permissions for all methods defined in {@link ALL_AZTEC_METHODS}
+ * on the 'aztec:mainnet' chain.
+ *
+ * @param provider - The {@link AztecRouterProvider} instance to use for the connection.
+ *                   This provider must be configured with appropriate transport and Aztec serializers.
+ * @param chainId - The {@link AztecChainId} to connect to (e.g., 'aztec:mainnet', 'aztec:31337').
+ *                  Defaults to 'aztec:mainnet'.
+ * @param methods - An array of method names for which permissions are requested.
+ *                  Defaults to {@link ALL_AZTEC_METHODS}.
+ * @returns A promise that resolves to an object containing the `sessionId` for the connection
+ *          and a fully initialized {@link AztecDappWallet} instance.
+ * @throws If the connection or wallet initialization fails.
+ *
+ * @example
+ * ```typescript
+ * const provider = new AztecRouterProvider(myTransport);
+ * const { sessionId, wallet } = await connectAztec(provider, 'aztec:testnet');
+ * const address = wallet.getAddress(); // Wallet is ready to use
+ * console.log('Connected with session ID:', sessionId, 'Wallet address:', address.toString());
+ * ```
+ */
+export declare function connectAztec(provider: AztecRouterProvider, chainId?: AztecChainId, methods?: readonly (keyof import('../types.js').AztecWalletMethodMap | string)[]): Promise<{
+    sessionId: string;
+    wallet: AztecDappWallet;
+}>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/client/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/client/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAKtE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,kpBA6BpB,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,GAAE,YAA8B,EACvC,OAAO,GAAE,SAAS,CAAC,MAAM,OAAO,aAAa,EAAE,oBAAoB,GAAG,MAAM,CAAC,EAAsB,GAClG,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC,CAWzD"}

package/dist/client/helpers.js

@@ -0,0 +1,79 @@
+import { createAztecWallet } from './aztec-dapp-wallet.js';
+import { createLogger } from '@aztec/foundation/log';
+const logger = createLogger('aztec-rpc-wallet:helpers');
+/**
+ * A comprehensive list of all JSON-RPC methods supported by the Aztec RPC wallet.
+ * This array includes standard Aztec wallet methods as well as WalletMesh-specific extensions (prefixed with `wm_`).
+ * It can be used when establishing a connection to request permissions for all available functionalities.
+ *
+ * @see {@link AztecWalletMethodMap} for detailed type information on each method.
+ * @see {@link connectAztec} and {@link connectAztecWithWallet} which use this list by default.
+ */
+export const ALL_AZTEC_METHODS = [
+    'aztec_getAddress',
+    'aztec_getCompleteAddress',
+    'aztec_getChainId',
+    'aztec_getVersion',
+    'aztec_sendTx',
+    'aztec_getTxReceipt',
+    'aztec_simulateTx',
+    'aztec_getNodeInfo',
+    'aztec_getBlockNumber',
+    'aztec_getCurrentBaseFees',
+    'aztec_registerSender',
+    'aztec_getSenders',
+    'aztec_removeSender',
+    'aztec_registerContract',
+    'aztec_registerContractClass',
+    'aztec_getContractMetadata',
+    'aztec_getContractClassMetadata',
+    'aztec_proveTx',
+    'aztec_profileTx',
+    'aztec_simulateUtility',
+    'aztec_getPrivateEvents',
+    'aztec_getPublicEvents',
+    'aztec_getPXEInfo',
+    'aztec_getBlock',
+    'aztec_createAuthWit',
+    'aztec_wmDeployContract',
+    'aztec_wmExecuteTx',
+    'aztec_wmSimulateTx',
+];
+/**
+ * Establishes a connection to an Aztec wallet service and creates an initialized {@link AztecDappWallet} instance.
+ * This function requests permissions for the specified methods on the given Aztec chain,
+ * then instantiates and initializes the wallet.
+ * Initialization includes fetching and caching essential data like the wallet address and chain ID.
+ *
+ * By default, it requests permissions for all methods defined in {@link ALL_AZTEC_METHODS}
+ * on the 'aztec:mainnet' chain.
+ *
+ * @param provider - The {@link AztecRouterProvider} instance to use for the connection.
+ *                   This provider must be configured with appropriate transport and Aztec serializers.
+ * @param chainId - The {@link AztecChainId} to connect to (e.g., 'aztec:mainnet', 'aztec:31337').
+ *                  Defaults to 'aztec:mainnet'.
+ * @param methods - An array of method names for which permissions are requested.
+ *                  Defaults to {@link ALL_AZTEC_METHODS}.
+ * @returns A promise that resolves to an object containing the `sessionId` for the connection
+ *          and a fully initialized {@link AztecDappWallet} instance.
+ * @throws If the connection or wallet initialization fails.
+ *
+ * @example
+ * ```typescript
+ * const provider = new AztecRouterProvider(myTransport);
+ * const { sessionId, wallet } = await connectAztec(provider, 'aztec:testnet');
+ * const address = wallet.getAddress(); // Wallet is ready to use
+ * console.log('Connected with session ID:', sessionId, 'Wallet address:', address.toString());
+ * ```
+ */
+export async function connectAztec(provider, chainId = 'aztec:mainnet', methods = ALL_AZTEC_METHODS) {
+    // Establish connection
+    const { sessionId } = await provider.connect({
+        [chainId]: [...methods],
+    });
+    // Create and initialize wallet (this pre-caches all synchronous values)
+    const wallet = await createAztecWallet(provider, chainId);
+    logger.debug(`Connected to Aztec wallet: ${sessionId}`);
+    return { sessionId, wallet };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbGllbnQvaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUUzRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFckQsTUFBTSxNQUFNLEdBQUcsWUFBWSxDQUFDLDBCQUEwQixDQUFDLENBQUM7QUFFeEQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHO0lBQy9CLGtCQUFrQjtJQUNsQiwwQkFBMEI7SUFDMUIsa0JBQWtCO0lBQ2xCLGtCQUFrQjtJQUNsQixjQUFjO0lBQ2Qsb0JBQW9CO0lBQ3BCLGtCQUFrQjtJQUNsQixtQkFBbUI7SUFDbkIsc0JBQXNCO0lBQ3RCLDBCQUEwQjtJQUMxQixzQkFBc0I7SUFDdEIsa0JBQWtCO0lBQ2xCLG9CQUFvQjtJQUNwQix3QkFBd0I7SUFDeEIsNkJBQTZCO0lBQzdCLDJCQUEyQjtJQUMzQixnQ0FBZ0M7SUFDaEMsZUFBZTtJQUNmLGlCQUFpQjtJQUNqQix1QkFBdUI7SUFDdkIsd0JBQXdCO0lBQ3hCLHVCQUF1QjtJQUN2QixrQkFBa0I7SUFDbEIsZ0JBQWdCO0lBQ2hCLHFCQUFxQjtJQUNyQix3QkFBd0I7SUFDeEIsbUJBQW1CO0lBQ25CLG9CQUFvQjtDQUNaLENBQUM7QUFFWDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0EwQkc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFlBQVksQ0FDaEMsUUFBNkIsRUFDN0IsVUFBd0IsZUFBZSxFQUN2QyxVQUFrRixpQkFBaUI7SUFFbkcsdUJBQXVCO0lBQ3ZCLE1BQU0sRUFBRSxTQUFTLEVBQUUsR0FBRyxNQUFNLFFBQVEsQ0FBQyxPQUFPLENBQUM7UUFDM0MsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFhO0tBQ3BDLENBQUMsQ0FBQztJQUVILHdFQUF3RTtJQUN4RSxNQUFNLE1BQU0sR0FBRyxNQUFNLGlCQUFpQixDQUFDLFFBQVEsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUMxRCxNQUFNLENBQUMsS0FBSyxDQUFDLDhCQUE4QixTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBRXhELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLENBQUM7QUFDL0IsQ0FBQyJ9

package/dist/client/register-serializers.d.ts

@@ -0,0 +1,41 @@
+import type { WalletRouterProvider } from '@walletmesh/router';
+/**
+ * Registers the {@link AztecWalletSerializer} for all relevant Aztec JSON-RPC methods
+ * on a given {@link WalletRouterProvider} instance.
+ *
+ * This utility function ensures that any `WalletRouterProvider` (not just the specialized
+ * {@link AztecRouterProvider}) can be configured to correctly handle serialization and
+ * deserialization of Aztec-specific data types (e.g., `AztecAddress`, `Fr`, `TxExecutionRequest`)
+ * when interacting with an Aztec wallet.
+ *
+ * It iterates through a predefined list of Aztec methods and associates them with
+ * the comprehensive {@link AztecWalletSerializer}.
+ *
+ * @param provider - The {@link WalletRouterProvider} instance on which to register the serializers.
+ *                   After this function call, the provider will be equipped to handle Aztec methods.
+ *
+ * @example
+ * ```typescript
+ * import { WalletRouterProvider } from '@walletmesh/router';
+ * import { registerAztecSerializers, ALL_AZTEC_METHODS } from '@walletmesh/aztec-rpc-wallet';
+ * import { MyCustomTransport } from './my-custom-transport';
+ *
+ * // 1. Create a generic WalletRouterProvider
+ * const transport = new MyCustomTransport();
+ * const provider = new WalletRouterProvider(transport);
+ *
+ * // 2. Register Aztec serializers on it
+ * registerAztecSerializers(provider);
+ *
+ * // 3. Now the provider can correctly handle Aztec methods and types
+ * await provider.connect({ 'aztec:testnet': ALL_AZTEC_METHODS });
+ * const address = await provider.call('aztec:testnet', { method: 'aztec_getAddress' });
+ * // 'address' will be correctly deserialized into an AztecAddress instance (or equivalent based on serializer)
+ * ```
+ *
+ * @see {@link AztecWalletSerializer} for the actual serialization logic.
+ * @see {@link AztecRouterProvider} for a provider that calls this automatically.
+ * @see {@link AztecWalletMethodMap} for the list of methods and their types.
+ */
+export declare function registerAztecSerializers(provider: WalletRouterProvider): void;
+//# sourceMappingURL=register-serializers.d.ts.map

package/dist/client/register-serializers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-serializers.d.ts","sourceRoot":"","sources":["../../src/client/register-serializers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAI/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAiE7E"}

package/dist/client/register-serializers.js

@@ -0,0 +1,97 @@
+import { AztecWalletSerializer } from '../wallet/serializers.js';
+/**
+ * Registers the {@link AztecWalletSerializer} for all relevant Aztec JSON-RPC methods
+ * on a given {@link WalletRouterProvider} instance.
+ *
+ * This utility function ensures that any `WalletRouterProvider` (not just the specialized
+ * {@link AztecRouterProvider}) can be configured to correctly handle serialization and
+ * deserialization of Aztec-specific data types (e.g., `AztecAddress`, `Fr`, `TxExecutionRequest`)
+ * when interacting with an Aztec wallet.
+ *
+ * It iterates through a predefined list of Aztec methods and associates them with
+ * the comprehensive {@link AztecWalletSerializer}.
+ *
+ * @param provider - The {@link WalletRouterProvider} instance on which to register the serializers.
+ *                   After this function call, the provider will be equipped to handle Aztec methods.
+ *
+ * @example
+ * ```typescript
+ * import { WalletRouterProvider } from '@walletmesh/router';
+ * import { registerAztecSerializers, ALL_AZTEC_METHODS } from '@walletmesh/aztec-rpc-wallet';
+ * import { MyCustomTransport } from './my-custom-transport';
+ *
+ * // 1. Create a generic WalletRouterProvider
+ * const transport = new MyCustomTransport();
+ * const provider = new WalletRouterProvider(transport);
+ *
+ * // 2. Register Aztec serializers on it
+ * registerAztecSerializers(provider);
+ *
+ * // 3. Now the provider can correctly handle Aztec methods and types
+ * await provider.connect({ 'aztec:testnet': ALL_AZTEC_METHODS });
+ * const address = await provider.call('aztec:testnet', { method: 'aztec_getAddress' });
+ * // 'address' will be correctly deserialized into an AztecAddress instance (or equivalent based on serializer)
+ * ```
+ *
+ * @see {@link AztecWalletSerializer} for the actual serialization logic.
+ * @see {@link AztecRouterProvider} for a provider that calls this automatically.
+ * @see {@link AztecWalletMethodMap} for the list of methods and their types.
+ */
+export function registerAztecSerializers(provider) {
+    // List of all Aztec wallet methods that need the AztecWalletSerializer.
+    // This list should ideally be kept in sync with ALL_AZTEC_METHODS or derived from AztecWalletMethodMap.
+    // Note: 'aztec_createTxExecutionRequest' is a client-side method, not a direct RPC method name.
+    // The actual RPC methods involved in tx creation are typically aztec_proveTx, aztec_sendTx, etc.
+    // However, if it were an RPC method, it would be listed here.
+    // For now, using a manually curated list that matches most of AztecWalletMethodMap.
+    const aztecMethods = [
+        // Chain/Node Methods
+        'aztec_getBlock',
+        'aztec_getBlockNumber',
+        'aztec_getChainId',
+        'aztec_getVersion',
+        'aztec_getNodeInfo',
+        'aztec_getProvenBlockNumber',
+        'aztec_getPXEInfo',
+        'aztec_getCurrentBaseFees',
+        // Account Methods
+        'aztec_getAddress',
+        'aztec_getCompleteAddress',
+        // AuthWitness Methods
+        'aztec_createAuthWit',
+        // Sender Methods
+        'aztec_registerSender',
+        'aztec_getSenders',
+        'aztec_removeSender',
+        // Contract Methods
+        'aztec_getContracts',
+        'aztec_getContractMetadata',
+        'aztec_getContractClassMetadata',
+        'aztec_registerContract',
+        'aztec_registerContractClass',
+        // Transaction Methods
+        // 'aztec_createTxExecutionRequest', // This is a client-side method, not an RPC method.
+        'aztec_proveTx',
+        'aztec_sendTx',
+        'aztec_getTxReceipt',
+        'aztec_simulateTx',
+        'aztec_profileTx',
+        'aztec_simulateUtility',
+        // Event Methods
+        'aztec_getPrivateEvents',
+        'aztec_getPublicEvents',
+        // Contract Interaction Methods (WalletMesh specific)
+        'aztec_wmExecuteTx',
+        'aztec_wmSimulateTx',
+        'aztec_wmDeployContract',
+        // Base WalletMesh method often included
+        'wm_getSupportedMethods',
+    ];
+    // Register the unified Aztec serializer for all methods
+    for (const method of aztecMethods) {
+        // The AztecWalletSerializer is already set up with all the proper
+        // serialization logic for each method
+        provider.registerMethodSerializer(method, AztecWalletSerializer);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXItc2VyaWFsaXplcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpZW50L3JlZ2lzdGVyLXNlcmlhbGl6ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBR2pFOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUNHO0FBQ0gsTUFBTSxVQUFVLHdCQUF3QixDQUFDLFFBQThCO0lBQ3JFLHdFQUF3RTtJQUN4RSx3R0FBd0c7SUFDeEcsZ0dBQWdHO0lBQ2hHLGlHQUFpRztJQUNqRyw4REFBOEQ7SUFDOUQsb0ZBQW9GO0lBQ3BGLE1BQU0sWUFBWSxHQUFtQztRQUNuRCxxQkFBcUI7UUFDckIsZ0JBQWdCO1FBQ2hCLHNCQUFzQjtRQUN0QixrQkFBa0I7UUFDbEIsa0JBQWtCO1FBQ2xCLG1CQUFtQjtRQUNuQiw0QkFBNEI7UUFDNUIsa0JBQWtCO1FBQ2xCLDBCQUEwQjtRQUUxQixrQkFBa0I7UUFDbEIsa0JBQWtCO1FBQ2xCLDBCQUEwQjtRQUUxQixzQkFBc0I7UUFDdEIscUJBQXFCO1FBRXJCLGlCQUFpQjtRQUNqQixzQkFBc0I7UUFDdEIsa0JBQWtCO1FBQ2xCLG9CQUFvQjtRQUVwQixtQkFBbUI7UUFDbkIsb0JBQW9CO1FBQ3BCLDJCQUEyQjtRQUMzQixnQ0FBZ0M7UUFDaEMsd0JBQXdCO1FBQ3hCLDZCQUE2QjtRQUU3QixzQkFBc0I7UUFDdEIsd0ZBQXdGO1FBQ3hGLGVBQWU7UUFDZixjQUFjO1FBQ2Qsb0JBQW9CO1FBQ3BCLGtCQUFrQjtRQUNsQixpQkFBaUI7UUFDakIsdUJBQXVCO1FBRXZCLGdCQUFnQjtRQUNoQix3QkFBd0I7UUFDeEIsdUJBQXVCO1FBRXZCLHFEQUFxRDtRQUNyRCxtQkFBbUI7UUFDbkIsb0JBQW9CO1FBQ3BCLHdCQUF3QjtRQUV4Qix3Q0FBd0M7UUFDeEMsd0JBQXdCO0tBQ3pCLENBQUM7SUFFRix3REFBd0Q7SUFDeEQsS0FBSyxNQUFNLE1BQU0sSUFBSSxZQUFZLEVBQUUsQ0FBQztRQUNsQyxrRUFBa0U7UUFDbEUsc0NBQXNDO1FBQ3RDLFFBQVEsQ0FBQyx3QkFBd0IsQ0FBQyxNQUFnQixFQUFFLHFCQUFxQixDQUFDLENBQUM7SUFDN0UsQ0FBQztBQUNILENBQUMifQ==

package/dist/contractArtifactCache.d.ts

@@ -1,49 +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 type { AztecAddress, ContractArtifact, Wallet } from '@aztec/aztec.js';
 /**
- * Caches contract artifacts to optimize contract interactions.
+ * Manages an in-memory cache for Aztec {@link ContractArtifact}s.
+ *
+ * This class is designed to optimize performance by reducing redundant fetches
+ * of contract artifacts. When an artifact is requested for a given contract address,
+ * the cache first checks its local store. If the artifact is not found (a cache miss),
+ * it uses the provided {@link Wallet} instance to retrieve the contract's metadata,
+ * then its class metadata (which includes the artifact), stores it in the cache,
+ * and finally returns it. Subsequent requests for the same artifact will be served
+ * directly from the cache.
+ *
+ * This caching strategy helps to:
+ * - Minimize network requests to the PXE or node for contract data.
+ * - Reduce processing overhead associated with fetching and parsing artifacts.
+ * - Conserve memory by reusing already loaded artifact instances.
  *
- * 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
+ * The cache is typically used within the `AztecHandlerContext` on the wallet-side
+ * to provide efficient artifact access to RPC method handlers.
  *
- * This caching mechanism helps reduce:
- * - Network requests to fetch contract data
- * - Processing overhead of parsing contract artifacts
- * - Memory usage by reusing existing artifacts
+ * @see {@link AztecHandlerContext}
+ * @see {@link Wallet}
+ * @see {@link ContractArtifact}
  */
 export declare class ContractArtifactCache {
-    /** Map of contract addresses to their artifacts */
+    /**
+     * In-memory map storing contract artifacts, keyed by their stringified {@link AztecAddress}.
+     * @internal
+     */
     private cache;
-    /** Reference to the wallet instance for fetching contract data */
+    /**
+     * Reference to the `aztec.js` {@link Wallet} instance used to fetch contract
+     * metadata and artifacts in case of a cache miss.
+     * @internal
+     */
     private wallet;
     /**
-     * Creates a new ContractArtifactCache instance.
-     * @param wallet - Wallet instance used to fetch contract data when cache misses occur
+     * Creates a new `ContractArtifactCache` instance.
+     *
+     * @param wallet - The `aztec.js` {@link Wallet} instance that will be used to
+     *                 fetch contract metadata and artifacts if they are not found
+     *                 in the cache. This wallet should be capable of calling
+     *                 `getContractMetadata` and `getContractClassMetadata`.
      */
     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.
+     * Retrieves the {@link ContractArtifact} for a given {@link AztecAddress}.
      *
-     * 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
+     * This method implements a cache-aside pattern:
+     * 1. It first checks if the artifact for the `contractAddress` is already in the cache.
+     * 2. If found (cache hit), the cached artifact is returned immediately.
+     * 3. If not found (cache miss):
+     *    a. It fetches the {@link ContractMetadata} for the `contractAddress` using the wallet.
+     *    b. It then fetches the {@link ContractClassMetadata} using the class ID from the contract metadata.
+     *       This class metadata is expected to contain the artifact.
+     *    c. The retrieved artifact is stored in the cache, associated with the `contractAddress`.
+     *    d. The artifact is then returned.
      *
-     * @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
+     * @param contractAddress - The {@link AztecAddress} of the contract whose artifact is to be retrieved.
+     * @returns A promise that resolves to the {@link ContractArtifact}.
+     * @throws {AztecWalletError} if the contract instance or its class (and thus artifact)
+     *                            is not registered with the wallet or cannot be found.
+     *                            Also re-throws other errors encountered during wallet calls.
      */
     getContractArtifact(contractAddress: AztecAddress): Promise<ContractArtifact>;
 }

package/dist/contractArtifactCache.d.ts.map

@@ -1 +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;CA6B3F"}
+{"version":3,"file":"contractArtifactCache.d.ts","sourceRoot":"","sources":["../src/contractArtifactCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAI9E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,qBAAqB;IAChC;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAuC;IAEpD;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;;;;OAOG;gBACS,MAAM,EAAE,MAAM;IAI1B;;;;;;;;;;;;;;;;;;OAkBG;IACU,mBAAmB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA+B3F"}

package/dist/contractArtifactCache.js

@@ -1,49 +1,62 @@
-/**
- * @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.
+ * Manages an in-memory cache for Aztec {@link ContractArtifact}s.
  *
- * 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 class is designed to optimize performance by reducing redundant fetches
+ * of contract artifacts. When an artifact is requested for a given contract address,
+ * the cache first checks its local store. If the artifact is not found (a cache miss),
+ * it uses the provided {@link Wallet} instance to retrieve the contract's metadata,
+ * then its class metadata (which includes the artifact), stores it in the cache,
+ * and finally returns it. Subsequent requests for the same artifact will be served
+ * directly from the cache.
  *
- * This caching mechanism helps reduce:
- * - Network requests to fetch contract data
- * - Processing overhead of parsing contract artifacts
- * - Memory usage by reusing existing artifacts
+ * This caching strategy helps to:
+ * - Minimize network requests to the PXE or node for contract data.
+ * - Reduce processing overhead associated with fetching and parsing artifacts.
+ * - Conserve memory by reusing already loaded artifact instances.
+ *
+ * The cache is typically used within the `AztecHandlerContext` on the wallet-side
+ * to provide efficient artifact access to RPC method handlers.
+ *
+ * @see {@link AztecHandlerContext}
+ * @see {@link Wallet}
+ * @see {@link ContractArtifact}
  */
 export class ContractArtifactCache {
     /**
-     * Creates a new ContractArtifactCache instance.
-     * @param wallet - Wallet instance used to fetch contract data when cache misses occur
+     * Creates a new `ContractArtifactCache` instance.
+     *
+     * @param wallet - The `aztec.js` {@link Wallet} instance that will be used to
+     *                 fetch contract metadata and artifacts if they are not found
+     *                 in the cache. This wallet should be capable of calling
+     *                 `getContractMetadata` and `getContractClassMetadata`.
      */
     constructor(wallet) {
-        /** Map of contract addresses to their artifacts */
+        /**
+         * In-memory map storing contract artifacts, keyed by their stringified {@link AztecAddress}.
+         * @internal
+         */
         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.
+     * Retrieves the {@link ContractArtifact} for a given {@link AztecAddress}.
      *
-     * 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
+     * This method implements a cache-aside pattern:
+     * 1. It first checks if the artifact for the `contractAddress` is already in the cache.
+     * 2. If found (cache hit), the cached artifact is returned immediately.
+     * 3. If not found (cache miss):
+     *    a. It fetches the {@link ContractMetadata} for the `contractAddress` using the wallet.
+     *    b. It then fetches the {@link ContractClassMetadata} using the class ID from the contract metadata.
+     *       This class metadata is expected to contain the artifact.
+     *    c. The retrieved artifact is stored in the cache, associated with the `contractAddress`.
+     *    d. The artifact is then returned.
      *
-     * @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
+     * @param contractAddress - The {@link AztecAddress} of the contract whose artifact is to be retrieved.
+     * @returns A promise that resolves to the {@link ContractArtifact}.
+     * @throws {AztecWalletError} if the contract instance or its class (and thus artifact)
+     *                            is not registered with the wallet or cannot be found.
+     *                            Also re-throws other errors encountered during wallet calls.
      */
     async getContractArtifact(contractAddress) {
         const addressStr = contractAddress.toString();
@@ -57,10 +70,10 @@ export class ContractArtifactCache {
             if (!contract) {
                 throw new AztecWalletError('contractInstanceNotRegistered', addressStr);
             }
-            const contractClassMetadata = await this.wallet.getContractClassMetadata(contract.contractClassId);
+            const contractClassMetadata = await this.wallet.getContractClassMetadata(contract.currentContractClassId);
             const artifact = contractClassMetadata.artifact;
             if (!artifact) {
-                throw new AztecWalletError('contractClassNotRegistered', contract.contractClassId.toString());
+                throw new AztecWalletError('contractClassNotRegistered', contract.currentContractClassId.toString());
             }
             this.cache.set(addressStr, artifact);
             return artifact;
@@ -74,4 +87,4 @@ export class ContractArtifactCache {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RBcnRpZmFjdENhY2hlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnRyYWN0QXJ0aWZhY3RDYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUlILE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUUvQzs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQU0sT0FBTyxxQkFBcUI7SUFNaEM7OztPQUdHO0lBQ0gsWUFBWSxNQUFjO1FBVDFCLG1EQUFtRDtRQUMzQyxVQUFLLEdBQUcsSUFBSSxHQUFHLEVBQTRCLENBQUM7UUFTbEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7SUFDdkIsQ0FBQztJQUVEOzs7Ozs7Ozs7Ozs7OztPQWNHO0lBQ0ksS0FBSyxDQUFDLG1CQUFtQixDQUFDLGVBQTZCO1FBQzVELE1BQU0sVUFBVSxHQUFHLGVBQWUsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUM5QyxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUMxQyxJQUFJLE1BQU0sRUFBRSxDQUFDO1lBQ1gsT0FBTyxNQUFNLENBQUM7UUFDaEIsQ0FBQztRQUVELElBQUksQ0FBQztZQUNILE1BQU0sZ0JBQWdCLEdBQUcsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLG1CQUFtQixDQUFDLGVBQWUsQ0FBQyxDQUFDO1lBQ2hGLE1BQU0sUUFBUSxHQUFHLGdCQUFnQixDQUFDLGdCQUFnQixDQUFDO1lBQ25ELElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztnQkFDZCxNQUFNLElBQUksZ0JBQWdCLENBQUMsK0JBQStCLEVBQUUsVUFBVSxDQUFDLENBQUM7WUFDMUUsQ0FBQztZQUVELE1BQU0scUJBQXFCLEdBQUcsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLHdCQUF3QixDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUMsQ0FBQztZQUNuRyxNQUFNLFFBQVEsR0FBRyxxQkFBcUIsQ0FBQyxRQUFRLENBQUM7WUFDaEQsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUNkLE1BQU0sSUFBSSxnQkFBZ0IsQ0FBQyw0QkFBNEIsRUFBRSxRQUFRLENBQUMsZUFBZSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7WUFDaEcsQ0FBQztZQUNELElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFVBQVUsRUFBRSxRQUFRLENBQUMsQ0FBQztZQUNyQyxPQUFPLFFBQVEsQ0FBQztRQUNsQixDQUFDO1FBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztZQUNmLElBQUksS0FBSyxZQUFZLGdCQUFnQixFQUFFLENBQUM7Z0JBQ3RDLE1BQU0sS0FBSyxDQUFDO1lBQ2QsQ0FBQztZQUNELE1BQU0sWUFBWSxHQUFHLEtBQUssWUFBWSxLQUFLLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLGVBQWUsQ0FBQztZQUM5RSxNQUFNLElBQUksZ0JBQWdCLENBQUMsK0JBQStCLEVBQUUsR0FBRyxVQUFVLEtBQUssWUFBWSxFQUFFLENBQUMsQ0FBQztRQUNoRyxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RBcnRpZmFjdENhY2hlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnRyYWN0QXJ0aWZhY3RDYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFL0M7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FzQkc7QUFDSCxNQUFNLE9BQU8scUJBQXFCO0lBY2hDOzs7Ozs7O09BT0c7SUFDSCxZQUFZLE1BQWM7UUFyQjFCOzs7V0FHRztRQUNLLFVBQUssR0FBRyxJQUFJLEdBQUcsRUFBNEIsQ0FBQztRQWtCbEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7SUFDdkIsQ0FBQztJQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7T0FrQkc7SUFDSSxLQUFLLENBQUMsbUJBQW1CLENBQUMsZUFBNkI7UUFDNUQsTUFBTSxVQUFVLEdBQUcsZUFBZSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQzlDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQzFDLElBQUksTUFBTSxFQUFFLENBQUM7WUFDWCxPQUFPLE1BQU0sQ0FBQztRQUNoQixDQUFDO1FBRUQsSUFBSSxDQUFDO1lBQ0gsTUFBTSxnQkFBZ0IsR0FBRyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsbUJBQW1CLENBQUMsZUFBZSxDQUFDLENBQUM7WUFDaEYsTUFBTSxRQUFRLEdBQUcsZ0JBQWdCLENBQUMsZ0JBQWdCLENBQUM7WUFDbkQsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUNkLE1BQU0sSUFBSSxnQkFBZ0IsQ0FBQywrQkFBK0IsRUFBRSxVQUFVLENBQUMsQ0FBQztZQUMxRSxDQUFDO1lBRUQsTUFBTSxxQkFBcUIsR0FBRyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsd0JBQXdCLENBQ3RFLFFBQVEsQ0FBQyxzQkFBc0IsQ0FDaEMsQ0FBQztZQUNGLE1BQU0sUUFBUSxHQUFHLHFCQUFxQixDQUFDLFFBQVEsQ0FBQztZQUNoRCxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7Z0JBQ2QsTUFBTSxJQUFJLGdCQUFnQixDQUFDLDRCQUE0QixFQUFFLFFBQVEsQ0FBQyxzQkFBc0IsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO1lBQ3ZHLENBQUM7WUFDRCxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUM7WUFDckMsT0FBTyxRQUFRLENBQUM7UUFDbEIsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixJQUFJLEtBQUssWUFBWSxnQkFBZ0IsRUFBRSxDQUFDO2dCQUN0QyxNQUFNLEtBQUssQ0FBQztZQUNkLENBQUM7WUFDRCxNQUFNLFlBQVksR0FBRyxLQUFLLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxlQUFlLENBQUM7WUFDOUUsTUFBTSxJQUFJLGdCQUFnQixDQUFDLCtCQUErQixFQUFFLEdBQUcsVUFBVSxLQUFLLFlBQVksRUFBRSxDQUFDLENBQUM7UUFDaEcsQ0FBQztJQUNILENBQUM7Q0FDRiJ9