@walletmesh/aztec-rpc-wallet 0.1.0

package/dist/handlers/transactions.js

@@ -0,0 +1,90 @@
+import { AuthWitness, AztecAddress, Contract, NoFeePaymentMethod, } from '@aztec/aztec.js';
+import { GasSettings } from '@aztec/circuits.js';
+import { AztecWalletError } from '../errors.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 async function sendTransaction(context, params) {
+    try {
+        // Setup the execution request without the calls for now
+        const executionRequestInit = {
+            calls: [],
+            authWitnesses: params.authwits?.map(AuthWitness.fromString) ?? [],
+            // TODO: Figure out what we should be doing with this fee parameter
+            fee: {
+                paymentMethod: new NoFeePaymentMethod(),
+                gasSettings: GasSettings.default({ maxFeesPerGas: await context.wallet.getCurrentBaseFees() }),
+            },
+        };
+        // Get artifacts and contracts first
+        const contractMap = new Map();
+        for (const c of params.functionCalls) {
+            const contractAddress = AztecAddress.fromString(c.contractAddress);
+            if (!contractMap.has(c.contractAddress)) {
+                const artifact = await context.contractArtifactCache.getContractArtifact(contractAddress);
+                const contract = await Contract.at(contractAddress, artifact, context.wallet);
+                contractMap.set(c.contractAddress, { contract, artifact });
+            }
+        }
+        // Now build the execution request
+        for (const c of params.functionCalls) {
+            // biome-ignore lint/style/noNonNullAssertion: we know the contract is in the map
+            const { contract } = contractMap.get(c.contractAddress);
+            const functionCall = contract.methods[c.functionName](...c.args);
+            executionRequestInit.calls.push(await functionCall.request());
+        }
+        const txExecutionRequest = await context.wallet.createTxExecutionRequest(executionRequestInit);
+        const simulatedTx = await context.wallet.simulateTx(txExecutionRequest, true /* simulatePublic */);
+        const txProvingResult = await context.wallet.proveTx(txExecutionRequest, simulatedTx.privateExecutionResult);
+        const txHash = await context.wallet.sendTx(txProvingResult.toTx());
+        return txHash.toString();
+    }
+    catch (error) {
+        throw new AztecWalletError('unknownInternalError');
+    }
+}
+/**
+ * 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 async function simulateTransaction(context, params) {
+    try {
+        const { contractAddress, functionName, args } = params;
+        const addr = AztecAddress.fromString(contractAddress);
+        const artifact = await context.contractArtifactCache.getContractArtifact(addr);
+        const contract = await Contract.at(addr, artifact, context.wallet);
+        const result = await contract.methods[functionName](...args).simulate();
+        // TODO: Is this sufficient for serializing the result?
+        switch (typeof result) {
+            case 'string':
+                return result;
+            case 'bigint':
+                return result.toString();
+            case 'object':
+                if (result instanceof Uint8Array) {
+                    return Buffer.from(result).toString('hex');
+                }
+                return result;
+            default:
+                return result;
+        }
+    }
+    catch (error) {
+        if (error instanceof AztecWalletError) {
+            throw error;
+        }
+        console.error('Error simulating transaction:', error);
+        throw new AztecWalletError('unknownInternalError', 'aztec_simulateTransaction');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/handlers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module handlers
+ *
+ * This module provides the core RPC method handling logic for the Aztec wallet.
+ * It routes incoming RPC requests to appropriate specialized handlers based on the method type.
+ *
+ * The handlers are organized into categories:
+ * - Base wallet methods (connect, getAccount, etc.)
+ * - Account wallet methods (chain operations, contract management, etc.)
+ * - Transaction methods (send, simulate)
+ *
+ * Each method handler validates inputs, performs the requested operation through the wallet,
+ * and returns properly formatted responses.
+ */
+import type { AztecWalletMethodMap } from './types.js';
+import { type AztecWalletContext } from './types.js';
+/**
+ * Main handler function that routes RPC method calls to appropriate specialized handlers.
+ *
+ * @param context - The wallet context containing PXE and wallet instances
+ * @param method - The RPC method being called
+ * @param params - Parameters passed to the method
+ * @returns Result from the method handler
+ * @throws {AztecWalletError} If method not supported or handler fails
+ */
+export declare function handler<M extends keyof AztecWalletMethodMap>(context: AztecWalletContext, method: M, params: AztecWalletMethodMap[M]['params']): Promise<AztecWalletMethodMap[M]['result']>;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../src/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,KAAK,kBAAkB,EAAuB,MAAM,YAAY,CAAC;AAK1E;;;;;;;;GAQG;AAEH,wBAAsB,OAAO,CAAC,CAAC,SAAS,MAAM,oBAAoB,EAChE,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,CAkC5C"}

package/dist/handlers.js

@@ -0,0 +1,55 @@
+/**
+ * @module handlers
+ *
+ * This module provides the core RPC method handling logic for the Aztec wallet.
+ * It routes incoming RPC requests to appropriate specialized handlers based on the method type.
+ *
+ * The handlers are organized into categories:
+ * - Base wallet methods (connect, getAccount, etc.)
+ * - Account wallet methods (chain operations, contract management, etc.)
+ * - Transaction methods (send, simulate)
+ *
+ * Each method handler validates inputs, performs the requested operation through the wallet,
+ * and returns properly formatted responses.
+ */
+import { BASE_WALLET_METHODS } from './types.js';
+import { AztecWalletError } from './errors.js';
+import { sendTransaction, simulateTransaction } from './handlers/transactions.js';
+import { aztecWalletHandler, AZTEC_WALLET_METHODS } from './handlers/aztecAccountWallet.js';
+/**
+ * Main handler function that routes RPC method calls to appropriate specialized handlers.
+ *
+ * @param context - The wallet context containing PXE and wallet instances
+ * @param method - The RPC method being called
+ * @param params - Parameters passed to the method
+ * @returns Result from the method handler
+ * @throws {AztecWalletError} If method not supported or handler fails
+ */
+export async function handler(context, method, params) {
+    if (AZTEC_WALLET_METHODS.includes(method)) {
+        return aztecWalletHandler(context, method, params);
+    }
+    switch (method) {
+        // Base wallet methods
+        case 'wm_getSupportedMethods': {
+            // Return combined list of supported methods from all handlers
+            return [...BASE_WALLET_METHODS, ...AZTEC_WALLET_METHODS];
+        }
+        case 'aztec_connect': {
+            // Basic connection validation
+            // Note: Main connection logic handled by provider
+            return true;
+        }
+        // Core wallet methods
+        case 'aztec_getAccount':
+            return (await context.wallet.getAddress()).toString();
+        // Transaction methods
+        case 'aztec_sendTransaction':
+            return await sendTransaction(context, params);
+        case 'aztec_simulateTransaction':
+            return await simulateTransaction(context, params);
+        default:
+            throw new AztecWalletError('invalidRequest', `Method not supported: ${String(method)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaGFuZGxlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUdILE9BQU8sRUFBMkIsbUJBQW1CLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDMUUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQy9DLE9BQU8sRUFBRSxlQUFlLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNsRixPQUFPLEVBQUUsa0JBQWtCLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUU1Rjs7Ozs7Ozs7R0FRRztBQUVILE1BQU0sQ0FBQyxLQUFLLFVBQVUsT0FBTyxDQUMzQixPQUEyQixFQUMzQixNQUFTLEVBQ1QsTUFBeUM7SUFFekMsSUFBSSxvQkFBb0IsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztRQUMxQyxPQUFPLGtCQUFrQixDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDckQsQ0FBQztJQUNELFFBQVEsTUFBTSxFQUFFLENBQUM7UUFDZixzQkFBc0I7UUFDdEIsS0FBSyx3QkFBd0IsQ0FBQyxDQUFDLENBQUM7WUFDOUIsOERBQThEO1lBQzlELE9BQU8sQ0FBQyxHQUFHLG1CQUFtQixFQUFFLEdBQUcsb0JBQW9CLENBQWEsQ0FBQztRQUN2RSxDQUFDO1FBQ0QsS0FBSyxlQUFlLENBQUMsQ0FBQyxDQUFDO1lBQ3JCLDhCQUE4QjtZQUM5QixrREFBa0Q7WUFDbEQsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO1FBQ0Qsc0JBQXNCO1FBQ3RCLEtBQUssa0JBQWtCO1lBQ3JCLE9BQU8sQ0FBQyxNQUFNLE9BQU8sQ0FBQyxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUV4RCxzQkFBc0I7UUFDdEIsS0FBSyx1QkFBdUI7WUFDMUIsT0FBTyxNQUFNLGVBQWUsQ0FDMUIsT0FBTyxFQUNQLE1BQWlFLENBQ2xFLENBQUM7UUFDSixLQUFLLDJCQUEyQjtZQUM5QixPQUFPLE1BQU0sbUJBQW1CLENBQzlCLE9BQU8sRUFDUCxNQUFxRSxDQUN0RSxDQUFDO1FBRUo7WUFDRSxNQUFNLElBQUksZ0JBQWdCLENBQUMsZ0JBQWdCLEVBQUUseUJBQXlCLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDNUYsQ0FBQztBQUNILENBQUMifQ==

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module @walletmesh/aztec-rpc-wallet
+ *
+ * This module provides a JSON-RPC implementation for interacting with Aztec Network.
+ * It enables communication between dApps and wallets through a standardized interface.
+ */
+/**
+ * Provider class for dApps to interact with Aztec wallets
+ * @see AztecProvider
+ */
+export { AztecProvider } from './provider.js';
+/**
+ * Minimal provider for direct interaction with an Aztec chain wallet
+ * @see AztecChainProvider
+ */
+export { AztecChainProvider } from './chainProvider.js';
+/**
+ * Wallet implementation that handles RPC requests from dApps
+ * @see AztecChainWallet
+ */
+export { AztecChainWallet } from './wallet.js';
+export { AztecChainWalletMiddleware } from './types.js';
+/**
+ * Cache for contract artifacts
+ * @see ContractArtifactCache
+ */
+export { ContractArtifactCache } from './contractArtifactCache.js';
+/**
+ * Error handling utilities for RPC communication
+ * @see AztecWalletError
+ * @see AztecWalletErrorMap
+ */
+export { AztecWalletError, AztecWalletErrorMap } from './errors.js';
+/**
+ * Type definitions for RPC interfaces
+ */
+export type { 
+/** Chain identifier type */
+AztecChainId, 
+/** Context passed through RPC middleware */
+AztecWalletContext, 
+/** Event map for wallet events */
+AztecWalletEventMap, 
+/** Base method map for core wallet functionality */
+AztecWalletBaseMethodMap, 
+/** Complete method map including all Aztec methods */
+AztecWalletMethodMap, 
+/** Middleware type for processing RPC requests */
+AztecWalletMiddleware, 
+/** Router client type for wallet mesh integration */
+AztecWalletRouterClient, 
+/** Handler type for wallet methods */
+AztecWalletMethodHandler, 
+/** Type for contract function calls */
+TransactionFunctionCall, 
+/** Parameters for transaction requests */
+TransactionParams, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C;;;GAGG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAExD;;;GAGG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAExD;;;GAGG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;;GAIG;AACH,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEpE;;GAEG;AACH,YAAY;AACV,4BAA4B;AAC5B,YAAY;AACZ,4CAA4C;AAC5C,kBAAkB;AAClB,kCAAkC;AAClC,mBAAmB;AACnB,oDAAoD;AACpD,wBAAwB;AACxB,sDAAsD;AACtD,oBAAoB;AACpB,kDAAkD;AAClD,qBAAqB;AACrB,qDAAqD;AACrD,uBAAuB;AACvB,sCAAsC;AACtC,wBAAwB;AACxB,uCAAuC;AACvC,uBAAuB;AACvB,0CAA0C;AAC1C,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,33 @@
+/**
+ * @module @walletmesh/aztec-rpc-wallet
+ *
+ * This module provides a JSON-RPC implementation for interacting with Aztec Network.
+ * It enables communication between dApps and wallets through a standardized interface.
+ */
+/**
+ * Provider class for dApps to interact with Aztec wallets
+ * @see AztecProvider
+ */
+export { AztecProvider } from './provider.js';
+/**
+ * Minimal provider for direct interaction with an Aztec chain wallet
+ * @see AztecChainProvider
+ */
+export { AztecChainProvider } from './chainProvider.js';
+/**
+ * Wallet implementation that handles RPC requests from dApps
+ * @see AztecChainWallet
+ */
+export { AztecChainWallet } from './wallet.js';
+/**
+ * Cache for contract artifacts
+ * @see ContractArtifactCache
+ */
+export { ContractArtifactCache } from './contractArtifactCache.js';
+/**
+ * Error handling utilities for RPC communication
+ * @see AztecWalletError
+ * @see AztecWalletErrorMap
+ */
+export { AztecWalletError, AztecWalletErrorMap } from './errors.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFFSDs7O0dBR0c7QUFDSCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTlDOzs7R0FHRztBQUNILE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXhEOzs7R0FHRztBQUNILE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUcvQzs7O0dBR0c7QUFDSCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUVuRTs7OztHQUlHO0FBQ0gsT0FBTyxFQUFFLGdCQUFnQixFQUFFLG1CQUFtQixFQUFFLE1BQU0sYUFBYSxDQUFDIn0=

package/dist/provider.d.ts

@@ -0,0 +1,105 @@
+import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
+import { WalletRouterProvider } from '@walletmesh/router';
+import type { AztecChainId, AztecWalletMethodMap, TransactionParams } from './types.js';
+/**
+ * Provider for interacting with multiple Aztec chains through WalletMesh router.
+ *
+ * This class implements the client-side interface for dApps to communicate with Aztec wallets.
+ * It handles:
+ * - Connection management for multiple chains
+ * - Session tracking
+ * - Method calls with proper context
+ * - Event handling for wallet state changes
+ *
+ * @example
+ * ```typescript
+ * // Create provider with transport
+ * const provider = new AztecProvider(transport);
+ *
+ * // Connect to chains
+ * await provider.connect(['aztec:testnet', 'aztec:devnet']);
+ *
+ * // Single operation using convenience method
+ * const address = await provider.getAccount('aztec:testnet');
+ *
+ * // Single operation using chain builder
+ * const txHash = await provider.chain('aztec:testnet')
+ *   .call('aztec_sendTransaction', {
+ *     functionCalls: [{
+ *       contractAddress: "0x...",
+ *       functionName: "transfer",
+ *       args: [recipient, amount]
+ *     }]
+ *   })
+ *   .execute();
+ *
+ * // Multiple operations in one call
+ * const [account, contracts, blockNumber] = await provider
+ *   .chain('aztec:testnet')
+ *   .call('aztec_getAccount')
+ *   .call('aztec_getContracts')
+ *   .call('aztec_getBlockNumber')
+ *   .execute();
+ * ```
+ */
+export declare class AztecProvider extends WalletRouterProvider {
+    private connectedChains;
+    private requestedChains;
+    constructor(transport: JSONRPCTransport);
+    /**
+     * Handles wallet state change events from the router.
+     * Updates the set of connected chains based on account availability.
+     * @param params - Event parameters containing chain ID and changes
+     */
+    private handleWalletStateChanged;
+    /**
+     * Handles session termination events from the router.
+     * Cleans up session state and connected chains.
+     * @param params - Event parameters containing session ID
+     */
+    private handleSessionTerminated;
+    /**
+     * Gets the list of currently connected chain IDs.
+     * @returns Array of connected chain IDs
+     */
+    getSupportedChains(): AztecChainId[];
+    getAccount(chainId: AztecChainId): Promise<string>;
+    /**
+     * Sends a transaction to the specified chain.
+     * @param chainId - ID of the chain to send transaction to
+     * @param params - Transaction parameters including function calls and optional auth witnesses
+     * @returns Transaction hash
+     * @throws {AztecWalletError} If transaction fails or response invalid
+     */
+    sendTransaction(chainId: AztecChainId, params: TransactionParams): Promise<string>;
+    /**
+     * Simulates a transaction without submitting it.
+     * @param chainId - ID of the chain to simulate on
+     * @param params - Transaction parameters to simulate
+     * @returns Simulation result
+     * @throws {AztecWalletError} If simulation fails
+     */
+    simulateTransaction(chainId: AztecChainId, params: TransactionParams['functionCalls'][0]): Promise<unknown>;
+    /**
+     * Registers a contract instance with the wallet.
+     * @param chainId - ID of the chain where contract is deployed
+     * @param params - Contract registration parameters
+     * @throws {AztecWalletError} If registration fails
+     */
+    registerContract(chainId: AztecChainId, params: AztecWalletMethodMap['aztec_registerContract']['params']): Promise<void>;
+    /**
+     * Registers a contract class with the wallet.
+     * @param chainId - ID of the chain to register on
+     * @param params - Contract class registration parameters
+     * @throws {AztecWalletError} If registration fails
+     */
+    registerContractClass(chainId: AztecChainId, params: AztecWalletMethodMap['aztec_registerContractClass']['params']): Promise<void>;
+    /**
+     * Registers a transaction sender with the wallet.
+     * @param chainId - ID of the chain to register on
+     * @param params - Sender registration parameters
+     * @throws {AztecWalletError} If registration fails
+     */
+    registerSender(chainId: AztecChainId, params: AztecWalletMethodMap['aztec_registerSender']['params']): Promise<void>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,aAAc,SAAQ,oBAAoB;IACrD,OAAO,CAAC,eAAe,CAAoB;IAC3C,OAAO,CAAC,eAAe,CAAoB;gBAE/B,SAAS,EAAE,gBAAgB;IAcvC;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IAiBhC;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAS/B;;;OAGG;IACI,kBAAkB,IAAI,YAAY,EAAE;IAI9B,UAAU,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAQ/D;;;;;;OAMG;IACU,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAQ/F;;;;;;OAMG;IACU,mBAAmB,CAC9B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,iBAAiB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GAC5C,OAAO,CAAC,OAAO,CAAC;IAQnB;;;;;OAKG;IACU,gBAAgB,CAC3B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,oBAAoB,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,GAC/D,OAAO,CAAC,IAAI,CAAC;IAIhB;;;;;OAKG;IACU,qBAAqB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,oBAAoB,CAAC,6BAA6B,CAAC,CAAC,QAAQ,CAAC,GACpE,OAAO,CAAC,IAAI,CAAC;IAIhB;;;;;OAKG;IACU,cAAc,CACzB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,oBAAoB,CAAC,sBAAsB,CAAC,CAAC,QAAQ,CAAC,GAC7D,OAAO,CAAC,IAAI,CAAC;CAGjB"}

package/dist/provider.js

@@ -0,0 +1,160 @@
+import { WalletRouterProvider } from '@walletmesh/router';
+import { AztecWalletError, AztecWalletErrorType } from './errors.js';
+/**
+ * Provider for interacting with multiple Aztec chains through WalletMesh router.
+ *
+ * This class implements the client-side interface for dApps to communicate with Aztec wallets.
+ * It handles:
+ * - Connection management for multiple chains
+ * - Session tracking
+ * - Method calls with proper context
+ * - Event handling for wallet state changes
+ *
+ * @example
+ * ```typescript
+ * // Create provider with transport
+ * const provider = new AztecProvider(transport);
+ *
+ * // Connect to chains
+ * await provider.connect(['aztec:testnet', 'aztec:devnet']);
+ *
+ * // Single operation using convenience method
+ * const address = await provider.getAccount('aztec:testnet');
+ *
+ * // Single operation using chain builder
+ * const txHash = await provider.chain('aztec:testnet')
+ *   .call('aztec_sendTransaction', {
+ *     functionCalls: [{
+ *       contractAddress: "0x...",
+ *       functionName: "transfer",
+ *       args: [recipient, amount]
+ *     }]
+ *   })
+ *   .execute();
+ *
+ * // Multiple operations in one call
+ * const [account, contracts, blockNumber] = await provider
+ *   .chain('aztec:testnet')
+ *   .call('aztec_getAccount')
+ *   .call('aztec_getContracts')
+ *   .call('aztec_getBlockNumber')
+ *   .execute();
+ * ```
+ */
+export class AztecProvider extends WalletRouterProvider {
+    constructor(transport) {
+        super(transport);
+        this.connectedChains = new Set();
+        this.requestedChains = new Set();
+        // Bind event handlers
+        this.handleWalletStateChanged = this.handleWalletStateChanged.bind(this);
+        this.handleSessionTerminated = this.handleSessionTerminated.bind(this);
+        // Register event handlers
+        this.on('wm_walletStateChanged', this.handleWalletStateChanged);
+        this.on('wm_sessionTerminated', this.handleSessionTerminated);
+    }
+    /**
+     * Handles wallet state change events from the router.
+     * Updates the set of connected chains based on account availability.
+     * @param params - Event parameters containing chain ID and changes
+     */
+    handleWalletStateChanged(params) {
+        const { chainId, changes } = params;
+        const aztecChainId = chainId;
+        // Only handle events for requested chains
+        if (this.requestedChains.has(aztecChainId)) {
+            if (changes.accounts && changes.accounts.length > 0) {
+                this.connectedChains.add(aztecChainId);
+                console.log('Chain connected:', aztecChainId);
+            }
+            else {
+                this.connectedChains.delete(aztecChainId);
+                console.log('Chain disconnected:', aztecChainId);
+            }
+            console.log('Connected chains:', Array.from(this.connectedChains));
+        }
+    }
+    /**
+     * Handles session termination events from the router.
+     * Cleans up session state and connected chains.
+     * @param params - Event parameters containing session ID
+     */
+    handleSessionTerminated(params) {
+        const { sessionId } = params;
+        if (sessionId === this.sessionId) {
+            this.connectedChains.clear();
+            this.requestedChains.clear();
+            console.log('Session terminated, all chains cleared');
+        }
+    }
+    /**
+     * Gets the list of currently connected chain IDs.
+     * @returns Array of connected chain IDs
+     */
+    getSupportedChains() {
+        return Array.from(this.connectedChains);
+    }
+    async getAccount(chainId) {
+        const result = await this.chain(chainId).call('aztec_getAccount').execute();
+        if (typeof result !== 'string' || !result) {
+            throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid account address returned');
+        }
+        return result;
+    }
+    /**
+     * Sends a transaction to the specified chain.
+     * @param chainId - ID of the chain to send transaction to
+     * @param params - Transaction parameters including function calls and optional auth witnesses
+     * @returns Transaction hash
+     * @throws {AztecWalletError} If transaction fails or response invalid
+     */
+    async sendTransaction(chainId, params) {
+        const result = await this.chain(chainId).call('aztec_sendTransaction', params).execute();
+        if (typeof result !== 'string' || !result) {
+            throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid transaction hash returned');
+        }
+        return result;
+    }
+    /**
+     * Simulates a transaction without submitting it.
+     * @param chainId - ID of the chain to simulate on
+     * @param params - Transaction parameters to simulate
+     * @returns Simulation result
+     * @throws {AztecWalletError} If simulation fails
+     */
+    async simulateTransaction(chainId, params) {
+        const result = await this.chain(chainId).call('aztec_simulateTransaction', params).execute();
+        if (result === undefined || result === null) {
+            throw new AztecWalletError(AztecWalletErrorType.invalidResponse, 'Invalid simulation result returned');
+        }
+        return result;
+    }
+    /**
+     * Registers a contract instance with the wallet.
+     * @param chainId - ID of the chain where contract is deployed
+     * @param params - Contract registration parameters
+     * @throws {AztecWalletError} If registration fails
+     */
+    async registerContract(chainId, params) {
+        await this.chain(chainId).call('aztec_registerContract', params).execute();
+    }
+    /**
+     * Registers a contract class with the wallet.
+     * @param chainId - ID of the chain to register on
+     * @param params - Contract class registration parameters
+     * @throws {AztecWalletError} If registration fails
+     */
+    async registerContractClass(chainId, params) {
+        await this.chain(chainId).call('aztec_registerContractClass', params).execute();
+    }
+    /**
+     * Registers a transaction sender with the wallet.
+     * @param chainId - ID of the chain to register on
+     * @param params - Sender registration parameters
+     * @throws {AztecWalletError} If registration fails
+     */
+    async registerSender(chainId, params) {
+        await this.chain(chainId).call('aztec_registerSender', params).execute();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDMUQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLG9CQUFvQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBR3JFOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBd0NHO0FBQ0gsTUFBTSxPQUFPLGFBQWMsU0FBUSxvQkFBb0I7SUFJckQsWUFBWSxTQUEyQjtRQUNyQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDakIsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFDO1FBQ2pDLElBQUksQ0FBQyxlQUFlLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQztRQUVqQyxzQkFBc0I7UUFDdEIsSUFBSSxDQUFDLHdCQUF3QixHQUFHLElBQUksQ0FBQyx3QkFBd0IsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDekUsSUFBSSxDQUFDLHVCQUF1QixHQUFHLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFdkUsMEJBQTBCO1FBQzFCLElBQUksQ0FBQyxFQUFFLENBQUMsdUJBQXVCLEVBQUUsSUFBSSxDQUFDLHdCQUF3QixDQUFDLENBQUM7UUFDaEUsSUFBSSxDQUFDLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxJQUFJLENBQUMsdUJBQXVCLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNLLHdCQUF3QixDQUFDLE1BQStDO1FBQzlFLE1BQU0sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLEdBQUcsTUFBTSxDQUFDO1FBQ3BDLE1BQU0sWUFBWSxHQUFHLE9BQXVCLENBQUM7UUFFN0MsMENBQTBDO1FBQzFDLElBQUksSUFBSSxDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLEVBQUUsQ0FBQztZQUMzQyxJQUFJLE9BQU8sQ0FBQyxRQUFRLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQ3BELElBQUksQ0FBQyxlQUFlLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO2dCQUN2QyxPQUFPLENBQUMsR0FBRyxDQUFDLGtCQUFrQixFQUFFLFlBQVksQ0FBQyxDQUFDO1lBQ2hELENBQUM7aUJBQU0sQ0FBQztnQkFDTixJQUFJLENBQUMsZUFBZSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztnQkFDMUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxxQkFBcUIsRUFBRSxZQUFZLENBQUMsQ0FBQztZQUNuRCxDQUFDO1lBQ0QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxtQkFBbUIsRUFBRSxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDO1FBQ3JFLENBQUM7SUFDSCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNLLHVCQUF1QixDQUFDLE1BQThDO1FBQzVFLE1BQU0sRUFBRSxTQUFTLEVBQUUsR0FBRyxNQUFNLENBQUM7UUFDN0IsSUFBSSxTQUFTLEtBQUssSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2pDLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDN0IsSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUM3QixPQUFPLENBQUMsR0FBRyxDQUFDLHdDQUF3QyxDQUFDLENBQUM7UUFDeEQsQ0FBQztJQUNILENBQUM7SUFFRDs7O09BR0c7SUFDSSxrQkFBa0I7UUFDdkIsT0FBTyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUMxQyxDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVUsQ0FBQyxPQUFxQjtRQUMzQyxNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDNUUsSUFBSSxPQUFPLE1BQU0sS0FBSyxRQUFRLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUMxQyxNQUFNLElBQUksZ0JBQWdCLENBQUMsb0JBQW9CLENBQUMsZUFBZSxFQUFFLGtDQUFrQyxDQUFDLENBQUM7UUFDdkcsQ0FBQztRQUNELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxLQUFLLENBQUMsZUFBZSxDQUFDLE9BQXFCLEVBQUUsTUFBeUI7UUFDM0UsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyx1QkFBdUIsRUFBRSxNQUFNLENBQUMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUN6RixJQUFJLE9BQU8sTUFBTSxLQUFLLFFBQVEsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQzFDLE1BQU0sSUFBSSxnQkFBZ0IsQ0FBQyxvQkFBb0IsQ0FBQyxlQUFlLEVBQUUsbUNBQW1DLENBQUMsQ0FBQztRQUN4RyxDQUFDO1FBQ0QsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNJLEtBQUssQ0FBQyxtQkFBbUIsQ0FDOUIsT0FBcUIsRUFDckIsTUFBNkM7UUFFN0MsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQywyQkFBMkIsRUFBRSxNQUFNLENBQUMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUM3RixJQUFJLE1BQU0sS0FBSyxTQUFTLElBQUksTUFBTSxLQUFLLElBQUksRUFBRSxDQUFDO1lBQzVDLE1BQU0sSUFBSSxnQkFBZ0IsQ0FBQyxvQkFBb0IsQ0FBQyxlQUFlLEVBQUUsb0NBQW9DLENBQUMsQ0FBQztRQUN6RyxDQUFDO1FBQ0QsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0ksS0FBSyxDQUFDLGdCQUFnQixDQUMzQixPQUFxQixFQUNyQixNQUFnRTtRQUVoRSxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLHdCQUF3QixFQUFFLE1BQU0sQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzdFLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNJLEtBQUssQ0FBQyxxQkFBcUIsQ0FDaEMsT0FBcUIsRUFDckIsTUFBcUU7UUFFckUsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyw2QkFBNkIsRUFBRSxNQUFNLENBQUMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNsRixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSSxLQUFLLENBQUMsY0FBYyxDQUN6QixPQUFxQixFQUNyQixNQUE4RDtRQUU5RCxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLHNCQUFzQixFQUFFLE1BQU0sQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzNFLENBQUM7Q0FDRiJ9