@aztec/wallet-sdk 3.0.0-nightly.20251122

package/dest/base-wallet/base_wallet.js

@@ -0,0 +1,225 @@
+import { GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT } from '@aztec/constants';
+import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { decodeFromAbi } from '@aztec/stdlib/abi';
+import { computePartialAddress, getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { Gas, GasSettings } from '@aztec/stdlib/gas';
+import { mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { inspect } from 'util';
+/**
+ * A base class for Wallet implementations
+ */ export class BaseWallet {
+    pxe;
+    aztecNode;
+    log;
+    baseFeePadding;
+    cancellableTransactions;
+    // Protected because we want to force wallets to instantiate their own PXE.
+    constructor(pxe, aztecNode){
+        this.pxe = pxe;
+        this.aztecNode = aztecNode;
+        this.log = createLogger('wallet-sdk:base_wallet');
+        this.baseFeePadding = 0.5;
+        this.cancellableTransactions = false;
+    }
+    /**
+   * Returns the list of aliased contacts associated with the wallet.
+   * This base implementation directly returns PXE's senders, but note that in general contacts are a superset of senders.
+   *  - Senders: Addresses we check during synching in case they sent us notes,
+   *  - Contacts: more general concept akin to a phone's contact list.
+   * @returns The aliased collection of AztecAddresses that form this wallet's address book
+   */ async getAddressBook() {
+        const senders = await this.pxe.getSenders();
+        return senders.map((sender)=>({
+                item: sender,
+                alias: ''
+            }));
+    }
+    async getChainInfo() {
+        const { l1ChainId, rollupVersion } = await this.aztecNode.getNodeInfo();
+        return {
+            chainId: new Fr(l1ChainId),
+            version: new Fr(rollupVersion)
+        };
+    }
+    async createTxExecutionRequestFromPayloadAndFee(executionPayload, from, feeOptions) {
+        const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+        const executionOptions = {
+            txNonce: Fr.random(),
+            cancellable: this.cancellableTransactions,
+            feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+        };
+        const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
+            feeExecutionPayload,
+            executionPayload
+        ]) : executionPayload;
+        const fromAccount = await this.getAccountFromAddress(from);
+        return fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, executionOptions);
+    }
+    async createAuthWit(from, messageHashOrIntent) {
+        const account = await this.getAccountFromAddress(from);
+        return account.createAuthWit(messageHashOrIntent);
+    }
+    async batch(methods) {
+        const results = [];
+        for (const method of methods){
+            const { name, args } = method;
+            // Type safety is guaranteed by the BatchedMethod type, which ensures that:
+            // 1. `name` is a valid batchable method name
+            // 2. `args` matches the parameter types of that specific method
+            // 3. The return type is correctly mapped in BatchResults<T>
+            // We use dynamic dispatch here for simplicity, but the types are enforced at the call site.
+            const fn = this[name];
+            const result = await fn.apply(this, args);
+            // Wrap result with method name for discriminated union deserialization
+            results.push({
+                name,
+                result
+            });
+        }
+        return results;
+    }
+    /**
+   * Completes partial user-provided fee options with wallet defaults.
+   * @param from - The address where the transaction is being sent from
+   * @param feePayer - The address paying for fees (if any fee payment method is embedded in the execution payload)
+   * @param gasSettings - User-provided partial gas settings
+   * @returns - Complete fee options that can be used to create a transaction execution request
+   */ async completeFeeOptions(from, feePayer, gasSettings) {
+        const maxFeesPerGas = gasSettings?.maxFeesPerGas ?? (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.baseFeePadding);
+        let accountFeePaymentMethodOptions;
+        // The transaction does not include a fee payment method, so we set the flag
+        // for the account to use its fee juice balance
+        if (!feePayer) {
+            accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE;
+        } else {
+            // The transaction includes fee payment method, so we check if we are the fee payer for it
+            // (this can only happen if the embedded payment method is FeeJuiceWithClaim)
+            accountFeePaymentMethodOptions = from.equals(feePayer) ? AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM : AccountFeePaymentMethodOptions.EXTERNAL;
+        }
+        const fullGasSettings = GasSettings.default({
+            ...gasSettings,
+            maxFeesPerGas
+        });
+        this.log.debug(`Using L2 gas settings`, fullGasSettings);
+        return {
+            gasSettings: fullGasSettings,
+            walletFeePaymentMethod: undefined,
+            accountFeePaymentMethodOptions
+        };
+    }
+    /**
+   * Completes partial user-provided fee options with unreasonably high gas limits
+   * for gas estimation. Uses the same logic as completeFeeOptions but sets high limits
+   * to avoid running out of gas during estimation.
+   * @param from - The address where the transaction is being sent from
+   * @param feePayer - The address paying for fees (if any fee payment method is embedded in the execution payload)
+   * @param gasSettings - User-provided partial gas settings
+   */ async completeFeeOptionsForEstimation(from, feePayer, gasSettings) {
+        const defaultFeeOptions = await this.completeFeeOptions(from, feePayer, gasSettings);
+        const { gasSettings: { maxFeesPerGas, maxPriorityFeesPerGas } } = defaultFeeOptions;
+        // Use unrealistically high gas limits for estimation to avoid running out of gas.
+        // They will be tuned down after the simulation.
+        const gasSettingsForEstimation = new GasSettings(new Gas(GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT), new Gas(GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT), maxFeesPerGas, maxPriorityFeesPerGas);
+        return {
+            ...defaultFeeOptions,
+            gasSettings: gasSettingsForEstimation
+        };
+    }
+    registerSender(address, _alias = '') {
+        return this.pxe.registerSender(address);
+    }
+    async registerContract(instance, artifact, secretKey) {
+        const { contractInstance: existingInstance } = await this.pxe.getContractMetadata(instance.address);
+        if (existingInstance) {
+            // Instance already registered in the wallet
+            if (artifact) {
+                const thisContractClass = await getContractClassFromArtifact(artifact);
+                if (!thisContractClass.id.equals(existingInstance.currentContractClassId)) {
+                    // wallet holds an outdated version of this contract
+                    await this.pxe.updateContract(instance.address, artifact);
+                    instance.currentContractClassId = thisContractClass.id;
+                }
+            }
+        // If no artifact provided, we just use the existing registration
+        } else {
+            // Instance not registered yet
+            if (!artifact) {
+                // Try to get the artifact from the wallet's contract class storage
+                const classMetadata = await this.pxe.getContractClassMetadata(instance.currentContractClassId, true);
+                if (!classMetadata.artifact) {
+                    throw new Error(`Cannot register contract at ${instance.address.toString()}: artifact is required but not provided, and wallet does not have the artifact for contract class ${instance.currentContractClassId.toString()}`);
+                }
+                artifact = classMetadata.artifact;
+            }
+            await this.pxe.registerContract({
+                artifact,
+                instance
+            });
+        }
+        if (secretKey) {
+            await this.pxe.registerAccount(secretKey, await computePartialAddress(instance));
+        }
+        return instance;
+    }
+    async simulateTx(executionPayload, opts) {
+        const feeOptions = opts.fee?.estimateGas ? await this.completeFeeOptionsForEstimation(opts.from, executionPayload.feePayer, opts.fee?.gasSettings) : await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+        const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
+        return this.pxe.simulateTx(txRequest, true, opts?.skipTxValidation, opts?.skipFeeEnforcement ?? true);
+    }
+    async profileTx(executionPayload, opts) {
+        const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+        const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
+        return this.pxe.profileTx(txRequest, opts.profileMode, opts.skipProofGeneration ?? true);
+    }
+    async sendTx(executionPayload, opts) {
+        const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+        const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
+        const provenTx = await this.pxe.proveTx(txRequest);
+        const tx = await provenTx.toTx();
+        const txHash = tx.getTxHash();
+        if (await this.aztecNode.getTxEffect(txHash)) {
+            throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
+        }
+        this.log.debug(`Sending transaction ${txHash}`);
+        await this.aztecNode.sendTx(tx).catch((err)=>{
+            throw this.contextualizeError(err, inspect(tx));
+        });
+        this.log.info(`Sent transaction ${txHash}`);
+        return txHash;
+    }
+    contextualizeError(err, ...context) {
+        let contextStr = '';
+        if (context.length > 0) {
+            contextStr = `\nContext:\n${context.join('\n')}`;
+        }
+        if (err instanceof SimulationError) {
+            err.setAztecContext(contextStr);
+        } else {
+            this.log.error(err.name, err);
+            this.log.debug(contextStr);
+        }
+        return err;
+    }
+    simulateUtility(call, authwits) {
+        return this.pxe.simulateUtility(call, authwits);
+    }
+    getContractClassMetadata(id, includeArtifact = false) {
+        return this.pxe.getContractClassMetadata(id, includeArtifact);
+    }
+    getContractMetadata(address) {
+        return this.pxe.getContractMetadata(address);
+    }
+    getTxReceipt(txHash) {
+        return this.aztecNode.getTxReceipt(txHash);
+    }
+    async getPrivateEvents(contractAddress, eventDef, from, limit, recipients = []) {
+        const events = await this.pxe.getPrivateEvents(contractAddress, eventDef.eventSelector, from, limit, recipients);
+        const decodedEvents = events.map((event /** PrivateEvent */ )=>decodeFromAbi([
+                eventDef.abiType
+            ], event.packedEvent));
+        return decodedEvents;
+    }
+}

package/dest/base-wallet/index.d.ts

@@ -0,0 +1,2 @@
+export { BaseWallet, type FeeOptions } from './base_wallet.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/base-wallet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/base-wallet/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dest/base-wallet/index.js

@@ -0,0 +1 @@
+export { BaseWallet } from './base_wallet.js';

package/dest/manager/index.d.ts

@@ -0,0 +1,8 @@
+export { WalletManager } from './wallet_manager.js';
+export type { WalletManagerConfig, ExtensionWalletConfig, WebWalletConfig, WalletProviderType, WalletProvider, DiscoverWalletsOptions, } from './types.js';
+export type { WalletInfo, WalletMessage, WalletResponse, DiscoveryRequest, DiscoveryResponse, } from '../providers/types.js';
+export { ChainInfoSchema } from '@aztec/aztec.js/account';
+export type { ChainInfo } from '@aztec/aztec.js/account';
+export { WalletSchema } from '@aztec/aztec.js/wallet';
+export { jsonStringify } from '@aztec/foundation/json-rpc';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/manager/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EACV,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,sBAAsB,GACvB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,UAAU,EACV,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC"}

package/dest/manager/index.js

@@ -0,0 +1,5 @@
+export { WalletManager } from './wallet_manager.js';
+// Re-export commonly needed utilities for wallet integration
+export { ChainInfoSchema } from '@aztec/aztec.js/account';
+export { WalletSchema } from '@aztec/aztec.js/wallet';
+export { jsonStringify } from '@aztec/foundation/json-rpc';

package/dest/manager/types.d.ts

@@ -0,0 +1,64 @@
+import type { ChainInfo } from '@aztec/aztec.js/account';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+/**
+ * Configuration for extension wallets
+ */
+export interface ExtensionWalletConfig {
+    /** Whether extension wallets are enabled */
+    enabled: boolean;
+    /** Optional list of allowed extension IDs (whitelist) */
+    allowList?: string[];
+    /** Optional list of blocked extension IDs (blacklist) */
+    blockList?: string[];
+}
+/**
+ * Configuration for web wallets
+ */
+export interface WebWalletConfig {
+    /** URLs of web wallet services */
+    urls: string[];
+}
+/**
+ * Configuration for the WalletManager
+ */
+export interface WalletManagerConfig {
+    /** Extension wallet configuration */
+    extensions?: ExtensionWalletConfig;
+    /** Web wallet configuration */
+    webWallets?: WebWalletConfig;
+}
+/**
+ * Type of wallet provider
+ */
+export type WalletProviderType = 'extension' | 'web' | 'embedded';
+/**
+ * A wallet provider that can connect to create a wallet instance.
+ * Chain information is already baked in from the discovery process.
+ */
+export interface WalletProvider {
+    /** Unique identifier for the provider */
+    id: string;
+    /** Type of wallet provider */
+    type: WalletProviderType;
+    /** Display name */
+    name: string;
+    /** Icon URL */
+    icon?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /**
+     * Connect to this wallet provider with an application ID
+     * @param appId - Application identifier for the requesting dapp
+     */
+    connect(appId: string): Promise<Wallet>;
+}
+/**
+ * Options for discovering wallets
+ */
+export interface DiscoverWalletsOptions {
+    /** Chain information to filter by */
+    chainInfo: ChainInfo;
+    /** Discovery timeout in milliseconds */
+    timeout?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dest/manager/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/manager/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,4CAA4C;IAC5C,OAAO,EAAE,OAAO,CAAC;IACjB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,qCAAqC;IACrC,UAAU,CAAC,EAAE,qBAAqB,CAAC;IACnC,+BAA+B;IAC/B,UAAU,CAAC,EAAE,eAAe,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,KAAK,GAAG,UAAU,CAAC;AAElE;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,8BAA8B;IAC9B,IAAI,EAAE,kBAAkB,CAAC;IACzB,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,qCAAqC;IACrC,SAAS,EAAE,SAAS,CAAC;IACrB,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dest/manager/types.js

@@ -0,0 +1,3 @@
+/**
+ * Options for discovering wallets
+ */ export { };

package/dest/manager/wallet_manager.d.ts

@@ -0,0 +1,27 @@
+import type { DiscoverWalletsOptions, WalletManagerConfig, WalletProvider } from './types.js';
+/**
+ * Manager for wallet discovery, configuration, and connection
+ */
+export declare class WalletManager {
+    private config;
+    private constructor();
+    /**
+     * Configures the WalletManager with provider settings
+     * @param config - Configuration options for wallet providers
+     */
+    static configure(config: WalletManagerConfig): WalletManager;
+    /**
+     * Discovers all available wallets for a given chain and version.
+     * Only returns wallets that support the requested chain and version.
+     * @param options - Discovery options including chain info and timeout
+     * @returns Array of wallet providers with baked-in chain info
+     */
+    getAvailableWallets(options: DiscoverWalletsOptions): Promise<WalletProvider[]>;
+    /**
+     * Checks if an extension is allowed based on allow/block lists
+     * @param extensionId - The extension ID to check
+     * @param config - Extension wallet configuration containing allow/block lists
+     */
+    private isExtensionAllowed;
+}
+//# sourceMappingURL=wallet_manager.d.ts.map

package/dest/manager/wallet_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet_manager.d.ts","sourceRoot":"","sources":["../../src/manager/wallet_manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAyB,mBAAmB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAErH;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAGZ;IAEF,OAAO;IAEP;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,mBAAmB,GAAG,aAAa;IAS5D;;;;;OAKG;IACG,mBAAmB,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAiCrF;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;CAc3B"}

package/dest/manager/wallet_manager.js

@@ -0,0 +1,77 @@
+import { ExtensionProvider, ExtensionWallet } from '../providers/extension/index.js';
+/**
+ * Manager for wallet discovery, configuration, and connection
+ */ export class WalletManager {
+    config = {
+        extensions: {
+            enabled: true
+        },
+        webWallets: {
+            urls: []
+        }
+    };
+    constructor(){}
+    /**
+   * Configures the WalletManager with provider settings
+   * @param config - Configuration options for wallet providers
+   */ static configure(config) {
+        const instance = new WalletManager();
+        instance.config = {
+            extensions: config.extensions ?? {
+                enabled: true
+            },
+            webWallets: config.webWallets ?? {
+                urls: []
+            }
+        };
+        return instance;
+    }
+    /**
+   * Discovers all available wallets for a given chain and version.
+   * Only returns wallets that support the requested chain and version.
+   * @param options - Discovery options including chain info and timeout
+   * @returns Array of wallet providers with baked-in chain info
+   */ async getAvailableWallets(options) {
+        const providers = [];
+        const { chainInfo } = options;
+        // Discover extension wallets
+        if (this.config.extensions?.enabled) {
+            const extensions = await ExtensionProvider.discoverExtensions(chainInfo, options.timeout);
+            const extensionConfig = this.config.extensions;
+            for (const ext of extensions){
+                // Apply allow/block lists
+                if (!this.isExtensionAllowed(ext.id, extensionConfig)) {
+                    continue;
+                }
+                providers.push({
+                    id: ext.id,
+                    type: 'extension',
+                    name: ext.name,
+                    icon: ext.icon,
+                    metadata: {
+                        version: ext.version
+                    },
+                    connect: (appId)=>Promise.resolve(ExtensionWallet.create(chainInfo, appId, ext.id))
+                });
+            }
+        }
+        // TODO: Add web wallet discovery when implemented
+        return providers;
+    }
+    /**
+   * Checks if an extension is allowed based on allow/block lists
+   * @param extensionId - The extension ID to check
+   * @param config - Extension wallet configuration containing allow/block lists
+   */ isExtensionAllowed(extensionId, config) {
+        // Check block list first
+        if (config.blockList && config.blockList.includes(extensionId)) {
+            return false;
+        }
+        // If allow list exists, extension must be in it
+        if (config.allowList && config.allowList.length > 0) {
+            return config.allowList.includes(extensionId);
+        }
+        // If no allow list, extension is allowed (unless blocked)
+        return true;
+    }
+}

package/dest/providers/extension/extension_provider.d.ts

@@ -0,0 +1,17 @@
+import type { ChainInfo } from '@aztec/aztec.js/account';
+import type { WalletInfo } from '../types.js';
+/**
+ * Provider for discovering and managing Aztec wallet extensions
+ */
+export declare class ExtensionProvider {
+    private static discoveredExtensions;
+    private static discoveryInProgress;
+    /**
+     * Discovers all installed Aztec wallet extensions
+     * @param chainInfo - Chain information to check if extensions support this network
+     * @param timeout - How long to wait for extensions to respond (ms)
+     * @returns Array of discovered extension information
+     */
+    static discoverExtensions(chainInfo: ChainInfo, timeout?: number): Promise<WalletInfo[]>;
+}
+//# sourceMappingURL=extension_provider.d.ts.map

package/dest/providers/extension/extension_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension_provider.d.ts","sourceRoot":"","sources":["../../../src/providers/extension/extension_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIzD,OAAO,KAAK,EAAuC,UAAU,EAAE,MAAM,aAAa,CAAC;AAEnF;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAsC;IACzE,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAS;IAE3C;;;;;OAKG;WACU,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,GAAE,MAAa,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;CAoDrG"}

package/dest/providers/extension/extension_provider.js

@@ -0,0 +1,56 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+/**
+ * Provider for discovering and managing Aztec wallet extensions
+ */ export class ExtensionProvider {
+    static discoveredExtensions = new Map();
+    static discoveryInProgress = false;
+    /**
+   * Discovers all installed Aztec wallet extensions
+   * @param chainInfo - Chain information to check if extensions support this network
+   * @param timeout - How long to wait for extensions to respond (ms)
+   * @returns Array of discovered extension information
+   */ static async discoverExtensions(chainInfo, timeout = 1000) {
+        // If discovery is in progress, wait for it to complete
+        if (this.discoveryInProgress) {
+            await new Promise((resolve)=>setTimeout(resolve, timeout));
+            return Array.from(this.discoveredExtensions.values());
+        }
+        this.discoveryInProgress = true;
+        this.discoveredExtensions.clear();
+        const { promise, resolve } = promiseWithResolvers();
+        const requestId = globalThis.crypto.randomUUID();
+        const responses = [];
+        // Set up listener for discovery responses
+        const handleMessage = (event)=>{
+            if (event.source !== window) {
+                return;
+            }
+            let data;
+            try {
+                data = JSON.parse(event.data);
+            } catch  {
+                return;
+            }
+            if (data.type === 'aztec-wallet-discovery-response' && data.requestId === requestId) {
+                responses.push(data.walletInfo);
+                this.discoveredExtensions.set(data.walletInfo.id, data.walletInfo);
+            }
+        };
+        window.addEventListener('message', handleMessage);
+        // Send discovery message
+        const discoveryMessage = {
+            type: 'aztec-wallet-discovery',
+            requestId,
+            chainInfo
+        };
+        window.postMessage(jsonStringify(discoveryMessage), '*');
+        // Wait for responses
+        setTimeout(()=>{
+            window.removeEventListener('message', handleMessage);
+            this.discoveryInProgress = false;
+            resolve(responses);
+        }, timeout);
+        return promise;
+    }
+}

package/dest/providers/extension/extension_wallet.d.ts

@@ -0,0 +1,23 @@
+import type { ChainInfo } from '@aztec/aztec.js/account';
+import { type Wallet } from '@aztec/aztec.js/wallet';
+/**
+ * A wallet implementation that communicates with browser extension wallets
+ * Supports multiple extensions by targeting specific extension IDs
+ */
+export declare class ExtensionWallet {
+    private chainInfo;
+    private appId;
+    private extensionId;
+    private inFlight;
+    private constructor();
+    /**
+     * Creates an ExtensionWallet instance that proxies wallet calls to a browser extension
+     * @param chainInfo - The chain information (chainId and version)
+     * @param appId - Application identifier for the requesting dapp
+     * @param extensionId - Specific extension ID to communicate with
+     * @returns A Proxy object that implements the Wallet interface
+     */
+    static create(chainInfo: ChainInfo, appId: string, extensionId: string): Wallet;
+    private postMessage;
+}
+//# sourceMappingURL=extension_wallet.d.ts.map

package/dest/providers/extension/extension_wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension_wallet.d.ts","sourceRoot":"","sources":["../../../src/providers/extension/extension_wallet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,wBAAwB,CAAC;AAsBnE;;;GAGG;AACH,qBAAa,eAAe;IAIxB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,WAAW;IALrB,OAAO,CAAC,QAAQ,CAAoD;IAEpE,OAAO;IAMP;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;IA+D/E,OAAO,CAAC,WAAW;CAiBpB"}

package/dest/providers/extension/extension_wallet.js

@@ -0,0 +1,96 @@
+import { WalletSchema } from '@aztec/aztec.js/wallet';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { schemaHasMethod } from '@aztec/foundation/schemas';
+/**
+ * A wallet implementation that communicates with browser extension wallets
+ * Supports multiple extensions by targeting specific extension IDs
+ */ export class ExtensionWallet {
+    chainInfo;
+    appId;
+    extensionId;
+    inFlight;
+    constructor(chainInfo, appId, extensionId){
+        this.chainInfo = chainInfo;
+        this.appId = appId;
+        this.extensionId = extensionId;
+        this.inFlight = new Map();
+    }
+    /**
+   * Creates an ExtensionWallet instance that proxies wallet calls to a browser extension
+   * @param chainInfo - The chain information (chainId and version)
+   * @param appId - Application identifier for the requesting dapp
+   * @param extensionId - Specific extension ID to communicate with
+   * @returns A Proxy object that implements the Wallet interface
+   */ static create(chainInfo, appId, extensionId) {
+        const wallet = new ExtensionWallet(chainInfo, appId, extensionId);
+        // Set up message listener for responses from extensions
+        window.addEventListener('message', (event)=>{
+            if (event.source !== window) {
+                return;
+            }
+            let data;
+            try {
+                data = JSON.parse(event.data);
+            } catch  {
+                return;
+            }
+            // Ignore request messages (only process responses)
+            if ('type' in data) {
+                return;
+            }
+            const { messageId, result, error, walletId: responseWalletId } = data;
+            if (!messageId || !responseWalletId) {
+                return;
+            }
+            if (wallet.extensionId !== responseWalletId) {
+                return;
+            }
+            if (!wallet.inFlight.has(messageId)) {
+                return;
+            }
+            const { resolve, reject } = wallet.inFlight.get(messageId);
+            if (error) {
+                reject(new Error(jsonStringify(error)));
+            } else {
+                resolve(result);
+            }
+            wallet.inFlight.delete(messageId);
+        });
+        // Create a Proxy that intercepts wallet method calls and forwards them to the extension
+        return new Proxy(wallet, {
+            get: (target, prop)=>{
+                if (schemaHasMethod(WalletSchema, prop.toString())) {
+                    return async (...args)=>{
+                        const result = await target.postMessage({
+                            type: prop.toString(),
+                            args
+                        });
+                        return WalletSchema[prop.toString()].returnType().parseAsync(result);
+                    };
+                } else {
+                    return target[prop];
+                }
+            }
+        });
+    }
+    postMessage(call) {
+        const messageId = globalThis.crypto.randomUUID();
+        const message = {
+            type: call.type,
+            args: call.args,
+            messageId,
+            chainInfo: this.chainInfo,
+            appId: this.appId,
+            walletId: this.extensionId
+        };
+        window.postMessage(jsonStringify(message), '*');
+        const { promise, resolve, reject } = promiseWithResolvers();
+        this.inFlight.set(messageId, {
+            promise,
+            resolve,
+            reject
+        });
+        return promise;
+    }
+}

package/dest/providers/extension/index.d.ts

@@ -0,0 +1,4 @@
+export { ExtensionWallet } from './extension_wallet.js';
+export { ExtensionProvider } from './extension_provider.js';
+export type { WalletInfo, WalletMessage, WalletResponse, DiscoveryRequest, DiscoveryResponse } from '../types.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/providers/extension/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/extension/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dest/providers/extension/index.js

@@ -0,0 +1,2 @@
+export { ExtensionWallet } from './extension_wallet.js';
+export { ExtensionProvider } from './extension_provider.js';