@dynamic-labs/aleo 0.0.0 → 4.67.0

package/src/connectors/AleoWalletAdapterConnector/AleoWalletAdapterConnector.js

@@ -0,0 +1,318 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { WalletReadyState, WalletDecryptPermission } from '@provablehq/aleo-wallet-standard';
+import { ShieldWalletAdapter } from '@provablehq/aleo-wallet-adaptor-shield';
+import { Network } from '@provablehq/aleo-types';
+import { DynamicError } from '@dynamic-labs/utils';
+import { logger } from '@dynamic-labs/wallet-connector-core';
+import { AleoWalletConnector } from '../AleoWalletConnector/AleoWalletConnector.js';
+
+/**
+ * Registry mapping wallet overrideKeys to their adapter constructors.
+ *
+ * Keys must match the wallet book entry key (i.e. the overrideKey).
+ * Add new adapter-based wallets here or via registerAdapter() at runtime.
+ */
+const adapterRegistry = {
+    shield: ShieldWalletAdapter,
+};
+const AleoNetworkToIdMap = {
+    [Network.MAINNET]: 0,
+    [Network.TESTNET]: 1,
+};
+const getNetworkByChainId = (chainId) => {
+    const entry = Object.entries(AleoNetworkToIdMap).find(([, id]) => id === chainId);
+    return entry === null || entry === void 0 ? void 0 : entry[0];
+};
+const WALLET_NOT_CONNECTED = 'Wallet not connected';
+const MICROCREDITS_PER_CREDIT = 1000000;
+const fetchPublicBalance = (address, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const networkSegment = network === Network.TESTNET ? 'testnet' : 'mainnet';
+    const url = `https://api.explorer.provable.com/v1/${networkSegment}/program/credits.aleo/mapping/account/${address}`;
+    const response = yield fetch(url);
+    if (!response.ok)
+        return BigInt(0);
+    const text = yield response.text();
+    if (!text || text === 'null')
+        return BigInt(0);
+    const cleaned = text.replace(/u64\.private|u64|[_"]/g, '').trim();
+    const value = BigInt(cleaned);
+    return value > BigInt(0) ? value : BigInt(0);
+});
+const extractRecordMicrocredits = (record) => {
+    var _a, _b;
+    if (!record || typeof record !== 'object')
+        return BigInt(0);
+    const r = record;
+    const plaintext = (_a = r.plaintext) !== null && _a !== void 0 ? _a : r.data;
+    if (!plaintext || typeof plaintext !== 'object')
+        return BigInt(0);
+    const pt = plaintext;
+    const microcredits = (_b = pt.microcredits) !== null && _b !== void 0 ? _b : pt.microcredits_;
+    if (typeof microcredits !== 'string')
+        return BigInt(0);
+    const value = BigInt(microcredits.replace(/u64\.private|u64|_/g, '').trim());
+    return value > BigInt(0) ? value : BigInt(0);
+};
+const fetchPrivateBalance = (adapter) => __awaiter(void 0, void 0, void 0, function* () {
+    const records = yield adapter.requestRecords('credits.aleo', true);
+    if (!Array.isArray(records))
+        return BigInt(0);
+    return records.reduce((total, record) => total + extractRecordMicrocredits(record), BigInt(0));
+});
+/**
+ * Connector for Aleo wallets that use a direct adapter interface rather than
+ * the @provablehq/aleo-wallet-standard StandardWallet feature-map API.
+ *
+ * Extends AleoWalletConnector so it inherits chain/network wiring and falls
+ * back to StandardWallet detection when no adapter is registered.
+ *
+ * To add a new adapter-based wallet, register its constructor:
+ * ```typescript
+ * AleoWalletAdapterConnector.registerAdapter('leowallet', LeoWalletAdapter);
+ * ```
+ */
+class AleoWalletAdapterConnector extends AleoWalletConnector {
+    /**
+     * Register an adapter constructor for a given wallet key.
+     * This is the primary extension point for non-standard wallets.
+     */
+    static registerAdapter(key, AdapterCtor) {
+        adapterRegistry[key] = AdapterCtor;
+    }
+    /**
+     * Instantiate the adapter for this connector's overrideKey.
+     * Returns undefined when no constructor is registered (falls back to StandardWallet).
+     */
+    createAdapter() {
+        const AdapterCtor = adapterRegistry[this.overrideKey];
+        return AdapterCtor ? new AdapterCtor() : undefined;
+    }
+    isInstalledOnBrowser() {
+        if (!this.adapter) {
+            this.adapter = this.createAdapter();
+        }
+        if (this.adapter) {
+            return this.adapter.readyState === WalletReadyState.INSTALLED;
+        }
+        // No adapter registered — fall back to StandardWallet window detection
+        return super.isInstalledOnBrowser();
+    }
+    supportsNetworkSwitching() {
+        return this.aleoNetworks.length > 1;
+    }
+    switchNetwork(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ networkChainId, }) {
+            if (!this.adapter) {
+                this.adapter = this.createAdapter();
+            }
+            if (networkChainId === undefined || networkChainId === null)
+                return;
+            const chainIdNum = Number(networkChainId);
+            const isValidNetwork = this.aleoNetworks.some((network) => Number(network.chainId) === chainIdNum);
+            if (!isValidNetwork) {
+                return;
+            }
+            const network = getNetworkByChainId(chainIdNum);
+            if (network && this.adapter) {
+                yield this.adapter.switchNetwork(network);
+                this.emit('chainChange', { chain: String(chainIdNum) });
+            }
+        });
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!((_a = this.adapter) === null || _a === void 0 ? void 0 : _a.network)) {
+                return undefined;
+            }
+            const id = AleoNetworkToIdMap[this.adapter.network];
+            return id !== undefined ? String(id) : undefined;
+        });
+    }
+    connect() {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (!this.adapter) {
+                this.adapter = this.createAdapter();
+            }
+            if (!this.adapter) {
+                // No adapter registered — fall back to StandardWallet connect
+                return _super.connect.call(this);
+            }
+            if (this.adapter.connected) {
+                return;
+            }
+            try {
+                yield this.adapter.connect(((_a = this.adapter) === null || _a === void 0 ? void 0 : _a.network) ||
+                    getNetworkByChainId(Number((_c = (_b = this.aleoNetworks[0]) === null || _b === void 0 ? void 0 : _b.chainId) !== null && _c !== void 0 ? _c : -1)) ||
+                    Network.MAINNET, WalletDecryptPermission.UponRequest);
+            }
+            catch (error) {
+                throw new DynamicError(`Failed to connect to ${this.name}: ${error}`);
+            }
+        });
+    }
+    getAddress() {
+        const _super = Object.create(null, {
+            getAddress: { get: () => super.getAddress }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (!this.adapter) {
+                return _super.getAddress.call(this);
+            }
+            const { account } = this.adapter;
+            if (account === null || account === void 0 ? void 0 : account.address) {
+                return account.address;
+            }
+            const result = yield this.adapter.connect(((_a = this.adapter) === null || _a === void 0 ? void 0 : _a.network) ||
+                getNetworkByChainId(Number((_c = (_b = this.aleoNetworks[0]) === null || _b === void 0 ? void 0 : _b.chainId) !== null && _c !== void 0 ? _c : -1)) ||
+                Network.MAINNET, WalletDecryptPermission.UponRequest);
+            return (_d = result === null || result === void 0 ? void 0 : result.address) !== null && _d !== void 0 ? _d : '';
+        });
+    }
+    getConnectedAccounts() {
+        const _super = Object.create(null, {
+            getConnectedAccounts: { get: () => super.getConnectedAccounts }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.adapter) {
+                return _super.getConnectedAccounts.call(this);
+            }
+            const { account } = this.adapter;
+            return (account === null || account === void 0 ? void 0 : account.address) ? [account.address] : [];
+        });
+    }
+    signMessage(messageToSign) {
+        const _super = Object.create(null, {
+            signMessage: { get: () => super.signMessage }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.adapter) {
+                return _super.signMessage.call(this, messageToSign);
+            }
+            if (!this.adapter.connected) {
+                throw new DynamicError(WALLET_NOT_CONNECTED);
+            }
+            try {
+                const messageBytes = new TextEncoder().encode(messageToSign);
+                const signatureBytes = yield this.adapter.signMessage(messageBytes);
+                return Array.from(signatureBytes, (b) => b.toString(16).padStart(2, '0')).join('');
+            }
+            catch (error) {
+                logger.error(`[${this.name}] Sign message failed:`, error);
+                throw new DynamicError(`Failed to sign message: ${error}`);
+            }
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.adapter) {
+                return '0';
+            }
+            if (!this.adapter.connected) {
+                yield this.connect();
+            }
+            const resolvedAddress = address !== null && address !== void 0 ? address : (_a = this.adapter.account) === null || _a === void 0 ? void 0 : _a.address;
+            if (!resolvedAddress) {
+                return '0';
+            }
+            const network = (_b = this.adapter.network) !== null && _b !== void 0 ? _b : Network.MAINNET;
+            let totalMicrocredits = BigInt(0);
+            try {
+                totalMicrocredits += yield fetchPublicBalance(resolvedAddress, network);
+            }
+            catch (error) {
+                logger.debug(`[${this.name}] Failed to fetch public balance:`, error);
+            }
+            try {
+                totalMicrocredits += yield fetchPrivateBalance(this.adapter);
+            }
+            catch (error) {
+                logger.debug(`[${this.name}] Failed to fetch private records:`, error);
+            }
+            return (Number(totalMicrocredits) / MICROCREDITS_PER_CREDIT).toFixed(6);
+        });
+    }
+    requestTransaction(transaction) {
+        const _super = Object.create(null, {
+            requestTransaction: { get: () => super.requestTransaction }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.adapter) {
+                return _super.requestTransaction.call(this, transaction);
+            }
+            if (!this.adapter.connected) {
+                throw new DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const [transition] = transaction.transitions;
+            if (!transition) {
+                throw new DynamicError('Transaction must have at least one transition');
+            }
+            const options = {
+                fee: transaction.fee,
+                function: transition.functionName,
+                inputs: transition.inputs,
+                privateFee: transaction.feePrivate,
+                program: transition.program,
+            };
+            const { transactionId } = yield this.adapter.executeTransaction(options);
+            return transactionId;
+        });
+    }
+    decrypt(ciphertext, options) {
+        const _super = Object.create(null, {
+            decrypt: { get: () => super.decrypt }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.adapter) {
+                return _super.decrypt.call(this, ciphertext, options);
+            }
+            if (!this.adapter.connected) {
+                throw new DynamicError(WALLET_NOT_CONNECTED);
+            }
+            return this.adapter.decrypt(ciphertext, options === null || options === void 0 ? void 0 : options.tpk, options === null || options === void 0 ? void 0 : options.programId, options === null || options === void 0 ? void 0 : options.functionName, options === null || options === void 0 ? void 0 : options.index);
+        });
+    }
+    requestRecords(program, options) {
+        const _super = Object.create(null, {
+            requestRecords: { get: () => super.requestRecords }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.adapter) {
+                return _super.requestRecords.call(this, program, options);
+            }
+            if (!this.adapter.connected) {
+                throw new DynamicError(WALLET_NOT_CONNECTED);
+            }
+            return this.adapter.requestRecords(program, (_a = options === null || options === void 0 ? void 0 : options.plaintext) !== null && _a !== void 0 ? _a : false);
+        });
+    }
+    endSession() {
+        const _super = Object.create(null, {
+            endSession: { get: () => super.endSession }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.adapter) {
+                return _super.endSession.call(this);
+            }
+            if (this.adapter.connected) {
+                try {
+                    yield this.adapter.disconnect();
+                }
+                catch (error) {
+                    logger.debug(`[${this.name}] Error during disconnect:`, error);
+                }
+            }
+            this.adapter = undefined;
+        });
+    }
+}
+
+export { AleoWalletAdapterConnector };

package/src/connectors/AleoWalletAdapterConnector/index.d.ts

@@ -0,0 +1,2 @@
+export { AleoWalletAdapterConnector } from './AleoWalletAdapterConnector';
+export type { AleoWalletAdapterConnectorOpts, AleoAdapterFactory, AleoAdapterConstructor, } from './AleoWalletAdapterConnector';

package/src/connectors/AleoWalletConnector/AleoWalletConnector.cjs

@@ -0,0 +1,219 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var aleoWalletStandard = require('@provablehq/aleo-wallet-standard');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+var AleoWallet = require('../../wallet/AleoWallet/AleoWallet.cjs');
+
+const WALLET_NOT_CONNECTED = 'Wallet not connected';
+const NetworkIdToAleoChain = {
+    0: aleoWalletStandard.ALEO_CHAINS.MAINNET,
+    1: aleoWalletStandard.ALEO_CHAINS.TESTNET,
+};
+const isTypedStandardWallet = (value) => typeof value === 'object' &&
+    value !== null &&
+    'features' in value &&
+    typeof value.features === 'object';
+class AleoWalletConnector extends walletConnectorCore.WalletConnectorBase {
+    constructor(opts) {
+        var _a;
+        super(opts);
+        this.ChainWallet = AleoWallet.AleoWallet;
+        this.name = 'Aleo Wallet';
+        this.overrideKey = 'aleowallet';
+        this.connectedChain = 'ALEO';
+        this.supportedChains = ['ALEO'];
+        this.switchNetworkOnlyFromWallet = true;
+        this.aleoNetworks = opts.aleoNetworks;
+        this.overrideKey = (_a = opts.overrideKey) !== null && _a !== void 0 ? _a : 'aleowallet';
+        this.windowKey = opts.windowKey;
+    }
+    /**
+     * Retrieves the StandardWallet instance from the window object.
+     * Caches the result after first successful lookup.
+     */
+    getStandardWallet() {
+        if (this.standardWallet) {
+            return this.standardWallet;
+        }
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        const wallet = window[this.windowKey];
+        if (isTypedStandardWallet(wallet)) {
+            this.standardWallet = wallet;
+        }
+        return this.standardWallet;
+    }
+    isInstalledOnBrowser() {
+        if (this.isInstalledCache !== undefined) {
+            return this.isInstalledCache;
+        }
+        this.isInstalledCache = Boolean(this.getStandardWallet());
+        return this.isInstalledCache;
+    }
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new utils.DynamicError(`${this.name} is not installed`);
+            }
+            const connectFeature = wallet.features[aleoWalletStandard.WalletFeatureName.CONNECT];
+            if (!(connectFeature === null || connectFeature === void 0 ? void 0 : connectFeature.available)) {
+                throw new utils.DynamicError(`${this.name} does not support connect`);
+            }
+            const networkId = (_a = this.aleoNetworks[0]) === null || _a === void 0 ? void 0 : _a.networkId;
+            const chain = (_b = NetworkIdToAleoChain[String(networkId)]) !== null && _b !== void 0 ? _b : aleoWalletStandard.ALEO_CHAINS.MAINNET;
+            try {
+                yield connectFeature.connect(aleoWalletStandard.WalletDecryptPermission.UponRequest, chain);
+            }
+            catch (error) {
+                throw new utils.DynamicError(`Failed to connect to ${this.name}: ${error}`);
+            }
+            const accountsFeature = wallet.features[aleoWalletStandard.WalletFeatureName.ACCOUNTS];
+            if (accountsFeature === null || accountsFeature === void 0 ? void 0 : accountsFeature.available) {
+                const accounts = yield accountsFeature.getAccounts();
+                [this.publicKey] = accounts;
+            }
+        });
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.publicKey) {
+                return this.publicKey;
+            }
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                return undefined;
+            }
+            const accountsFeature = wallet.features[aleoWalletStandard.WalletFeatureName.ACCOUNTS];
+            if (!(accountsFeature === null || accountsFeature === void 0 ? void 0 : accountsFeature.available)) {
+                return undefined;
+            }
+            const accounts = yield accountsFeature.getAccounts();
+            [this.publicKey] = accounts;
+            return this.publicKey;
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                return [];
+            }
+            const accountsFeature = wallet.features[aleoWalletStandard.WalletFeatureName.ACCOUNTS];
+            if (!(accountsFeature === null || accountsFeature === void 0 ? void 0 : accountsFeature.available)) {
+                return [];
+            }
+            return accountsFeature.getAccounts();
+        });
+    }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                return aleoWalletStandard.ALEO_CHAINS.MAINNET;
+            }
+            const chainFeature = wallet.features[aleoWalletStandard.WalletFeatureName.CHAINS];
+            if (!(chainFeature === null || chainFeature === void 0 ? void 0 : chainFeature.available)) {
+                return aleoWalletStandard.ALEO_CHAINS.MAINNET;
+            }
+            try {
+                const chains = yield chainFeature.getChains();
+                return (_a = chains[0]) !== null && _a !== void 0 ? _a : aleoWalletStandard.ALEO_CHAINS.MAINNET;
+            }
+            catch (_b) {
+                return aleoWalletStandard.ALEO_CHAINS.MAINNET;
+            }
+        });
+    }
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new utils.DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const signFeature = wallet.features[aleoWalletStandard.WalletFeatureName.SIGN];
+            if (!(signFeature === null || signFeature === void 0 ? void 0 : signFeature.available)) {
+                throw new utils.DynamicError(`${this.name} does not support message signing`);
+            }
+            try {
+                return yield signFeature.signMessage(messageToSign);
+            }
+            catch (error) {
+                walletConnectorCore.logger.error(`[${this.name}] Sign message failed:`, error);
+                throw new utils.DynamicError(`Failed to sign message: ${error}`);
+            }
+        });
+    }
+    requestTransaction(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new utils.DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const executeFeature = wallet.features[aleoWalletStandard.WalletFeatureName.EXECUTE];
+            if (!(executeFeature === null || executeFeature === void 0 ? void 0 : executeFeature.available)) {
+                throw new utils.DynamicError(`${this.name} does not support transaction execution`);
+            }
+            return executeFeature.requestTransaction(transaction);
+        });
+    }
+    decrypt(ciphertext, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new utils.DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const decryptFeature = wallet.features[aleoWalletStandard.WalletFeatureName.DECRYPT];
+            if (!(decryptFeature === null || decryptFeature === void 0 ? void 0 : decryptFeature.available)) {
+                throw new utils.DynamicError(`${this.name} does not support decryption`);
+            }
+            return decryptFeature.decrypt(ciphertext, options);
+        });
+    }
+    requestRecords(program, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new utils.DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const recordsFeature = wallet.features[aleoWalletStandard.WalletFeatureName.REQUEST_RECORDS];
+            if (!(recordsFeature === null || recordsFeature === void 0 ? void 0 : recordsFeature.available)) {
+                throw new utils.DynamicError(`${this.name} does not support record requests`);
+            }
+            return recordsFeature.requestRecords(program, options);
+        });
+    }
+    getEnabledNetworks() {
+        return this.aleoNetworks;
+    }
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                return;
+            }
+            const connectFeature = wallet.features[aleoWalletStandard.WalletFeatureName.CONNECT];
+            if (connectFeature === null || connectFeature === void 0 ? void 0 : connectFeature.available) {
+                try {
+                    yield connectFeature.disconnect();
+                }
+                catch (error) {
+                    walletConnectorCore.logger.debug(`[${this.name}] Error during disconnect:`, error);
+                }
+            }
+            this.publicKey = undefined;
+            this.standardWallet = undefined;
+            this.isInstalledCache = undefined;
+        });
+    }
+}
+
+exports.AleoWalletConnector = AleoWalletConnector;

package/src/connectors/AleoWalletConnector/AleoWalletConnector.d.ts

@@ -0,0 +1,111 @@
+import { WalletFeatureName, WalletDecryptPermission, type AleoChain, type StandardWallet } from '@provablehq/aleo-wallet-standard';
+import { Chain, WalletConnectorBase, WalletMetadata } from '@dynamic-labs/wallet-connector-core';
+import type { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import type { GenericNetwork } from '@dynamic-labs/types';
+import { AleoWallet } from '../../wallet/AleoWallet';
+import type { AleoTransaction } from '../../types';
+/**
+ * Feature-specific types for type-safe access to StandardWallet features
+ */
+type ConnectFeatureDetails = {
+    available: boolean;
+    connect(decryptPermission: WalletDecryptPermission, network: AleoChain, programs?: string[]): Promise<void>;
+    disconnect(): Promise<void>;
+};
+type AccountsFeatureDetails = {
+    available: boolean;
+    getAccounts(): Promise<string[]>;
+};
+type SignFeatureDetails = {
+    available: boolean;
+    signMessage(message: string): Promise<string>;
+};
+type ExecuteFeatureDetails = {
+    available: boolean;
+    requestTransaction(transaction: AleoTransaction): Promise<string>;
+};
+type ChainFeatureDetails = {
+    available: boolean;
+    getChains(): Promise<AleoChain[]>;
+};
+type SwitchNetworkFeatureDetails = {
+    available: boolean;
+    switchNetwork(network: AleoChain): Promise<void>;
+};
+type DecryptFeatureDetails = {
+    available: boolean;
+    decrypt(ciphertext: string, options?: {
+        tpk?: string;
+        programId?: string;
+        functionName?: string;
+        index?: number;
+    }): Promise<string>;
+};
+type RequestRecordsFeatureDetails = {
+    available: boolean;
+    requestRecords(program: string, options?: {
+        plaintext?: boolean;
+    }): Promise<unknown[]>;
+};
+type TypedStandardWallet = Omit<StandardWallet, 'features'> & {
+    features: {
+        [WalletFeatureName.CONNECT]?: ConnectFeatureDetails;
+        [WalletFeatureName.ACCOUNTS]?: AccountsFeatureDetails;
+        [WalletFeatureName.SIGN]?: SignFeatureDetails;
+        [WalletFeatureName.EXECUTE]?: ExecuteFeatureDetails;
+        [WalletFeatureName.CHAINS]?: ChainFeatureDetails;
+        [WalletFeatureName.SWITCH_NETWORK]?: SwitchNetworkFeatureDetails;
+        [WalletFeatureName.DECRYPT]?: DecryptFeatureDetails;
+        [WalletFeatureName.REQUEST_RECORDS]?: RequestRecordsFeatureDetails;
+    };
+};
+export type AleoWalletConnectorOpts = {
+    walletBook: WalletBookSchema;
+    aleoNetworks: GenericNetwork[];
+    metadata?: WalletMetadata;
+    overrideKey?: string;
+    walletData?: WalletBookSchema['wallets'][string];
+    /**
+     * The key on window where the wallet injects itself (e.g. 'shield')
+     * Comes from the wallet book injectedConfig.walletStandard.providerId
+     */
+    windowKey: string;
+};
+export declare abstract class AleoWalletConnector extends WalletConnectorBase<typeof AleoWallet> {
+    ChainWallet: typeof AleoWallet;
+    name: string;
+    overrideKey: string;
+    connectedChain: Chain;
+    supportedChains: Chain[];
+    switchNetworkOnlyFromWallet: boolean;
+    protected aleoNetworks: GenericNetwork[];
+    protected windowKey: string;
+    private standardWallet;
+    private publicKey;
+    private isInstalledCache;
+    constructor(opts: AleoWalletConnectorOpts);
+    /**
+     * Retrieves the StandardWallet instance from the window object.
+     * Caches the result after first successful lookup.
+     */
+    getStandardWallet(): TypedStandardWallet | undefined;
+    isInstalledOnBrowser(): boolean;
+    connect(): Promise<void>;
+    getAddress(): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+    getNetwork(): Promise<string | undefined>;
+    signMessage(messageToSign: string): Promise<string>;
+    requestTransaction(transaction: AleoTransaction): Promise<string>;
+    decrypt(ciphertext: string, options?: {
+        tpk?: string;
+        programId?: string;
+        functionName?: string;
+        index?: number;
+    }): Promise<string>;
+    requestRecords(program: string, options?: {
+        plaintext?: boolean;
+    }): Promise<unknown[]>;
+    getEnabledNetworks(): GenericNetwork[];
+    endSession(): Promise<void>;
+}
+export {};