@dynamic-labs/aleo 0.0.0 → 4.67.0

package/src/connectors/AleoWalletConnector/AleoWalletConnector.js

@@ -0,0 +1,215 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { ALEO_CHAINS, WalletFeatureName, WalletDecryptPermission } from '@provablehq/aleo-wallet-standard';
+import { WalletConnectorBase, logger } from '@dynamic-labs/wallet-connector-core';
+import { DynamicError } from '@dynamic-labs/utils';
+import { AleoWallet } from '../../wallet/AleoWallet/AleoWallet.js';
+
+const WALLET_NOT_CONNECTED = 'Wallet not connected';
+const NetworkIdToAleoChain = {
+    0: ALEO_CHAINS.MAINNET,
+    1: ALEO_CHAINS.TESTNET,
+};
+const isTypedStandardWallet = (value) => typeof value === 'object' &&
+    value !== null &&
+    'features' in value &&
+    typeof value.features === 'object';
+class AleoWalletConnector extends WalletConnectorBase {
+    constructor(opts) {
+        var _a;
+        super(opts);
+        this.ChainWallet = 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 __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new DynamicError(`${this.name} is not installed`);
+            }
+            const connectFeature = wallet.features[WalletFeatureName.CONNECT];
+            if (!(connectFeature === null || connectFeature === void 0 ? void 0 : connectFeature.available)) {
+                throw new 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 : ALEO_CHAINS.MAINNET;
+            try {
+                yield connectFeature.connect(WalletDecryptPermission.UponRequest, chain);
+            }
+            catch (error) {
+                throw new DynamicError(`Failed to connect to ${this.name}: ${error}`);
+            }
+            const accountsFeature = wallet.features[WalletFeatureName.ACCOUNTS];
+            if (accountsFeature === null || accountsFeature === void 0 ? void 0 : accountsFeature.available) {
+                const accounts = yield accountsFeature.getAccounts();
+                [this.publicKey] = accounts;
+            }
+        });
+    }
+    getAddress() {
+        return __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[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 __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                return [];
+            }
+            const accountsFeature = wallet.features[WalletFeatureName.ACCOUNTS];
+            if (!(accountsFeature === null || accountsFeature === void 0 ? void 0 : accountsFeature.available)) {
+                return [];
+            }
+            return accountsFeature.getAccounts();
+        });
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                return ALEO_CHAINS.MAINNET;
+            }
+            const chainFeature = wallet.features[WalletFeatureName.CHAINS];
+            if (!(chainFeature === null || chainFeature === void 0 ? void 0 : chainFeature.available)) {
+                return ALEO_CHAINS.MAINNET;
+            }
+            try {
+                const chains = yield chainFeature.getChains();
+                return (_a = chains[0]) !== null && _a !== void 0 ? _a : ALEO_CHAINS.MAINNET;
+            }
+            catch (_b) {
+                return ALEO_CHAINS.MAINNET;
+            }
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const signFeature = wallet.features[WalletFeatureName.SIGN];
+            if (!(signFeature === null || signFeature === void 0 ? void 0 : signFeature.available)) {
+                throw new DynamicError(`${this.name} does not support message signing`);
+            }
+            try {
+                return yield signFeature.signMessage(messageToSign);
+            }
+            catch (error) {
+                logger.error(`[${this.name}] Sign message failed:`, error);
+                throw new DynamicError(`Failed to sign message: ${error}`);
+            }
+        });
+    }
+    requestTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const executeFeature = wallet.features[WalletFeatureName.EXECUTE];
+            if (!(executeFeature === null || executeFeature === void 0 ? void 0 : executeFeature.available)) {
+                throw new DynamicError(`${this.name} does not support transaction execution`);
+            }
+            return executeFeature.requestTransaction(transaction);
+        });
+    }
+    decrypt(ciphertext, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const decryptFeature = wallet.features[WalletFeatureName.DECRYPT];
+            if (!(decryptFeature === null || decryptFeature === void 0 ? void 0 : decryptFeature.available)) {
+                throw new DynamicError(`${this.name} does not support decryption`);
+            }
+            return decryptFeature.decrypt(ciphertext, options);
+        });
+    }
+    requestRecords(program, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                throw new DynamicError(WALLET_NOT_CONNECTED);
+            }
+            const recordsFeature = wallet.features[WalletFeatureName.REQUEST_RECORDS];
+            if (!(recordsFeature === null || recordsFeature === void 0 ? void 0 : recordsFeature.available)) {
+                throw new DynamicError(`${this.name} does not support record requests`);
+            }
+            return recordsFeature.requestRecords(program, options);
+        });
+    }
+    getEnabledNetworks() {
+        return this.aleoNetworks;
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getStandardWallet();
+            if (!wallet) {
+                return;
+            }
+            const connectFeature = wallet.features[WalletFeatureName.CONNECT];
+            if (connectFeature === null || connectFeature === void 0 ? void 0 : connectFeature.available) {
+                try {
+                    yield connectFeature.disconnect();
+                }
+                catch (error) {
+                    logger.debug(`[${this.name}] Error during disconnect:`, error);
+                }
+            }
+            this.publicKey = undefined;
+            this.standardWallet = undefined;
+            this.isInstalledCache = undefined;
+        });
+    }
+}
+
+export { AleoWalletConnector };

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

@@ -0,0 +1,2 @@
+export { AleoWalletConnector } from './AleoWalletConnector';
+export type { AleoWalletConnectorOpts } from './AleoWalletConnector';

package/src/index.cjs

@@ -0,0 +1,39 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assertPackageVersion = require('@dynamic-labs/assert-package-version');
+var _package = require('../package.cjs');
+var fetchAleoWalletAdapterConnectors = require('./utils/fetchAleoWalletAdapterConnectors/fetchAleoWalletAdapterConnectors.cjs');
+var AleoWalletConnector = require('./connectors/AleoWalletConnector/AleoWalletConnector.cjs');
+var AleoWalletAdapterConnector = require('./connectors/AleoWalletAdapterConnector/AleoWalletAdapterConnector.cjs');
+var isAleoWallet = require('./wallet/isAleoWallet/isAleoWallet.cjs');
+var aleoWalletStandard = require('@provablehq/aleo-wallet-standard');
+
+assertPackageVersion.assertPackageVersion('@dynamic-labs/aleo', _package.version);
+const AleoWalletConnectors = (props) => [
+    // ...fetchAleoWalletConnectors(props),
+    ...fetchAleoWalletAdapterConnectors.fetchAleoWalletAdapterConnectors(props),
+];
+
+exports.AleoWalletConnector = AleoWalletConnector.AleoWalletConnector;
+exports.AleoWalletAdapterConnector = AleoWalletAdapterConnector.AleoWalletAdapterConnector;
+exports.isAleoWallet = isAleoWallet.isAleoWallet;
+Object.defineProperty(exports, 'ALEO_CHAINS', {
+  enumerable: true,
+  get: function () { return aleoWalletStandard.ALEO_CHAINS; }
+});
+Object.defineProperty(exports, 'WalletDecryptPermission', {
+  enumerable: true,
+  get: function () { return aleoWalletStandard.WalletDecryptPermission; }
+});
+Object.defineProperty(exports, 'WalletFeatureName', {
+  enumerable: true,
+  get: function () { return aleoWalletStandard.WalletFeatureName; }
+});
+Object.defineProperty(exports, 'WalletReadyState', {
+  enumerable: true,
+  get: function () { return aleoWalletStandard.WalletReadyState; }
+});
+exports.AleoWalletConnectors = AleoWalletConnectors;

package/src/index.d.ts

@@ -0,0 +1,14 @@
+import type { GenericNetwork } from '@dynamic-labs/types';
+import type { WalletBookSchema } from '@dynamic-labs/wallet-book';
+export { AleoWalletConnector } from './connectors/AleoWalletConnector';
+export type { AleoWalletConnectorOpts } from './connectors/AleoWalletConnector';
+export { AleoWalletAdapterConnector } from './connectors/AleoWalletAdapterConnector';
+export type { AleoWalletAdapterConnectorOpts, AleoAdapterFactory, AleoAdapterConstructor, } from './connectors/AleoWalletAdapterConnector';
+export { isAleoWallet } from './wallet/isAleoWallet';
+export type { AleoTransaction, AleoTransition } from './types';
+export { ALEO_CHAINS, WalletDecryptPermission, WalletFeatureName, WalletReadyState, } from './types';
+export type { AleoChain, StandardWallet } from './types';
+export declare const AleoWalletConnectors: (props: {
+    walletBook: WalletBookSchema;
+    aleoNetworks: GenericNetwork[];
+}) => import("dist/packages/wallet-connector-core/src").WalletConnectorConstructor[];

package/src/index.js

@@ -0,0 +1,16 @@
+'use client'
+import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
+import { version } from '../package.js';
+import { fetchAleoWalletAdapterConnectors } from './utils/fetchAleoWalletAdapterConnectors/fetchAleoWalletAdapterConnectors.js';
+export { AleoWalletConnector } from './connectors/AleoWalletConnector/AleoWalletConnector.js';
+export { AleoWalletAdapterConnector } from './connectors/AleoWalletAdapterConnector/AleoWalletAdapterConnector.js';
+export { isAleoWallet } from './wallet/isAleoWallet/isAleoWallet.js';
+export { ALEO_CHAINS, WalletDecryptPermission, WalletFeatureName, WalletReadyState } from '@provablehq/aleo-wallet-standard';
+
+assertPackageVersion('@dynamic-labs/aleo', version);
+const AleoWalletConnectors = (props) => [
+    // ...fetchAleoWalletConnectors(props),
+    ...fetchAleoWalletAdapterConnectors(props),
+];
+
+export { AleoWalletConnectors };

package/src/types.d.ts

@@ -0,0 +1,42 @@
+import { AleoChain, WalletDecryptPermission, WalletReadyState } from '@provablehq/aleo-wallet-standard';
+export { WalletFeatureName, WalletDecryptPermission, WalletReadyState, ALEO_CHAINS, } from '@provablehq/aleo-wallet-standard';
+export type { AleoChain, StandardWallet, WalletFeatures, WalletAdapter, WalletAdapterProps, WalletEvents, } from '@provablehq/aleo-wallet-standard';
+export type AleoTransition = {
+    program: string;
+    functionName: string;
+    inputs: unknown[];
+};
+export type AleoTransaction = {
+    address: string;
+    chainId: string;
+    transitions: AleoTransition[];
+    fee: number;
+    feePrivate: boolean;
+};
+/**
+ * Minimal interface for non-standard Aleo wallet adapters.
+ *
+ * Wallets that don't implement the @provablehq/aleo-wallet-standard
+ * StandardWallet interface (e.g. Leo, Puzzle, Fox via @demox-labs adapters)
+ * can be wrapped by implementing this interface.
+ */
+export type IAleoAdapter = {
+    publicKey: string | null | undefined;
+    connected: boolean;
+    readyState: WalletReadyState | string;
+    connect(decryptPermission?: WalletDecryptPermission, network?: AleoChain, programs?: string[]): Promise<{
+        address: string;
+    }>;
+    disconnect(): Promise<void>;
+    signMessage(message: 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[]>;
+};

package/src/utils/fetchAleoWalletAdapterConnectors/fetchAleoWalletAdapterConnectors.cjs

@@ -0,0 +1,71 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletBook = require('@dynamic-labs/wallet-book');
+var AleoWalletAdapterConnector = require('../../connectors/AleoWalletAdapterConnector/AleoWalletAdapterConnector.cjs');
+
+/**
+ * Checks whether a wallet book entry targets the non-standard Aleo adapter path.
+ *
+ * A wallet qualifies if it has an injectedConfig for the 'aleo' chain with the
+ * 'aleo-wallet-adapter:' feature flag (distinct from 'aleo-wallet-standard:').
+ */
+const isValidAleoWalletAdapterWallet = (wallet) => {
+    var _a;
+    return Boolean((_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => {
+        var _a, _b;
+        return config.chain === 'aleo' &&
+            Array.isArray((_a = config.walletStandard) === null || _a === void 0 ? void 0 : _a.features) &&
+            config.walletStandard.features.includes('aleo-wallet-adapter:') &&
+            ((_b = config.walletStandard) === null || _b === void 0 ? void 0 : _b.providerId);
+    }));
+};
+/**
+ * Builds a connector constructor for every non-standard Aleo wallet found in
+ * the wallet book (those using 'aleo-wallet-adapter:' rather than the
+ * StandardWallet feature map).
+ *
+ * Each constructor is an anonymous AleoWalletAdapterConnector subclass.
+ * Connect those wallets by registering their adapter constructors:
+ * ```typescript
+ * AleoWalletAdapterConnector.registerAdapter('leowallet', LeoWalletAdapter);
+ * ```
+ */
+const fetchAleoWalletAdapterConnectors = ({ walletBook: walletBook$1, aleoNetworks, }) => {
+    var _a;
+    return Object.entries((_a = walletBook$1 === null || walletBook$1 === void 0 ? void 0 : walletBook$1.wallets) !== null && _a !== void 0 ? _a : {})
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        .filter(([_, wallet]) => isValidAleoWalletAdapterWallet(wallet))
+        .map(([key, wallet]) => {
+        var _a, _b, _c, _d, _e, _f;
+        const name = (_b = (_a = wallet.shortName) !== null && _a !== void 0 ? _a : wallet.name) !== null && _b !== void 0 ? _b : key;
+        const windowKey = (_f = (_e = (_d = (_c = wallet.injectedConfig) === null || _c === void 0 ? void 0 : _c.find((c) => c.chain === 'aleo')) === null || _d === void 0 ? void 0 : _d.walletStandard) === null || _e === void 0 ? void 0 : _e.providerId) !== null && _f !== void 0 ? _f : key;
+        return class extends AleoWalletAdapterConnector.AleoWalletAdapterConnector {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            constructor(props) {
+                var _a;
+                super(Object.assign(Object.assign({}, props), { aleoNetworks, metadata: {
+                        brandColor: undefined,
+                        deepLinks: undefined,
+                        downloadLinks: undefined,
+                        groupKey: undefined,
+                        icon: ((_a = wallet === null || wallet === void 0 ? void 0 : wallet.brand) === null || _a === void 0 ? void 0 : _a.spriteId)
+                            ? walletBook.renderTemplate('iconicUrl', wallet.brand.spriteId)
+                            : '',
+                        id: key,
+                        name,
+                        rdns: undefined,
+                        supportedHardwareWallets: undefined,
+                        walletLimitations: undefined,
+                    }, overrideKey: key, walletData: wallet, windowKey }));
+                this.name = name;
+                this.overrideKey = key;
+            }
+        };
+    });
+};
+
+exports.fetchAleoWalletAdapterConnectors = fetchAleoWalletAdapterConnectors;
+exports.isValidAleoWalletAdapterWallet = isValidAleoWalletAdapterWallet;

package/src/utils/fetchAleoWalletAdapterConnectors/fetchAleoWalletAdapterConnectors.d.ts

@@ -0,0 +1,25 @@
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+import type { GenericNetwork } from '@dynamic-labs/types';
+/**
+ * Checks whether a wallet book entry targets the non-standard Aleo adapter path.
+ *
+ * A wallet qualifies if it has an injectedConfig for the 'aleo' chain with the
+ * 'aleo-wallet-adapter:' feature flag (distinct from 'aleo-wallet-standard:').
+ */
+export declare const isValidAleoWalletAdapterWallet: (wallet: WalletBookSchema['wallets'][string]) => boolean;
+/**
+ * Builds a connector constructor for every non-standard Aleo wallet found in
+ * the wallet book (those using 'aleo-wallet-adapter:' rather than the
+ * StandardWallet feature map).
+ *
+ * Each constructor is an anonymous AleoWalletAdapterConnector subclass.
+ * Connect those wallets by registering their adapter constructors:
+ * ```typescript
+ * AleoWalletAdapterConnector.registerAdapter('leowallet', LeoWalletAdapter);
+ * ```
+ */
+export declare const fetchAleoWalletAdapterConnectors: ({ walletBook, aleoNetworks, }: {
+    walletBook: WalletBookSchema;
+    aleoNetworks: GenericNetwork[];
+}) => WalletConnectorConstructor[];

package/src/utils/fetchAleoWalletAdapterConnectors/fetchAleoWalletAdapterConnectors.js

@@ -0,0 +1,66 @@
+'use client'
+import { renderTemplate } from '@dynamic-labs/wallet-book';
+import { AleoWalletAdapterConnector } from '../../connectors/AleoWalletAdapterConnector/AleoWalletAdapterConnector.js';
+
+/**
+ * Checks whether a wallet book entry targets the non-standard Aleo adapter path.
+ *
+ * A wallet qualifies if it has an injectedConfig for the 'aleo' chain with the
+ * 'aleo-wallet-adapter:' feature flag (distinct from 'aleo-wallet-standard:').
+ */
+const isValidAleoWalletAdapterWallet = (wallet) => {
+    var _a;
+    return Boolean((_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => {
+        var _a, _b;
+        return config.chain === 'aleo' &&
+            Array.isArray((_a = config.walletStandard) === null || _a === void 0 ? void 0 : _a.features) &&
+            config.walletStandard.features.includes('aleo-wallet-adapter:') &&
+            ((_b = config.walletStandard) === null || _b === void 0 ? void 0 : _b.providerId);
+    }));
+};
+/**
+ * Builds a connector constructor for every non-standard Aleo wallet found in
+ * the wallet book (those using 'aleo-wallet-adapter:' rather than the
+ * StandardWallet feature map).
+ *
+ * Each constructor is an anonymous AleoWalletAdapterConnector subclass.
+ * Connect those wallets by registering their adapter constructors:
+ * ```typescript
+ * AleoWalletAdapterConnector.registerAdapter('leowallet', LeoWalletAdapter);
+ * ```
+ */
+const fetchAleoWalletAdapterConnectors = ({ walletBook, aleoNetworks, }) => {
+    var _a;
+    return Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        .filter(([_, wallet]) => isValidAleoWalletAdapterWallet(wallet))
+        .map(([key, wallet]) => {
+        var _a, _b, _c, _d, _e, _f;
+        const name = (_b = (_a = wallet.shortName) !== null && _a !== void 0 ? _a : wallet.name) !== null && _b !== void 0 ? _b : key;
+        const windowKey = (_f = (_e = (_d = (_c = wallet.injectedConfig) === null || _c === void 0 ? void 0 : _c.find((c) => c.chain === 'aleo')) === null || _d === void 0 ? void 0 : _d.walletStandard) === null || _e === void 0 ? void 0 : _e.providerId) !== null && _f !== void 0 ? _f : key;
+        return class extends AleoWalletAdapterConnector {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            constructor(props) {
+                var _a;
+                super(Object.assign(Object.assign({}, props), { aleoNetworks, metadata: {
+                        brandColor: undefined,
+                        deepLinks: undefined,
+                        downloadLinks: undefined,
+                        groupKey: undefined,
+                        icon: ((_a = wallet === null || wallet === void 0 ? void 0 : wallet.brand) === null || _a === void 0 ? void 0 : _a.spriteId)
+                            ? renderTemplate('iconicUrl', wallet.brand.spriteId)
+                            : '',
+                        id: key,
+                        name,
+                        rdns: undefined,
+                        supportedHardwareWallets: undefined,
+                        walletLimitations: undefined,
+                    }, overrideKey: key, walletData: wallet, windowKey }));
+                this.name = name;
+                this.overrideKey = key;
+            }
+        };
+    });
+};
+
+export { fetchAleoWalletAdapterConnectors, isValidAleoWalletAdapterWallet };

package/src/utils/fetchAleoWalletAdapterConnectors/index.d.ts

@@ -0,0 +1 @@
+export { fetchAleoWalletAdapterConnectors, isValidAleoWalletAdapterWallet, } from './fetchAleoWalletAdapterConnectors';

package/src/wallet/AleoWallet/AleoWallet.cjs

@@ -0,0 +1,105 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+
+class AleoWallet extends walletConnectorCore.Wallet {
+    sendBalance(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ amount, toAddress, token, }) {
+            var _b, _c, _d;
+            const chainId = (_b = (yield this._connector.getNetwork())) !== null && _b !== void 0 ? _b : '0';
+            const decimals = (_c = token === null || token === void 0 ? void 0 : token.decimals) !== null && _c !== void 0 ? _c : 6;
+            const microcredits = BigInt(Math.round(parseFloat(amount) * Math.pow(10, decimals)));
+            const program = (_d = token === null || token === void 0 ? void 0 : token.address) !== null && _d !== void 0 ? _d : 'credits.aleo';
+            const transaction = {
+                address: this.address,
+                chainId,
+                fee: 50000,
+                feePrivate: false,
+                transitions: [
+                    {
+                        functionName: 'transfer_public',
+                        inputs: [toAddress, `${microcredits}u64`],
+                        program,
+                    },
+                ],
+            };
+            return this._connector.requestTransaction(transaction);
+        });
+    }
+    getBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = (yield this._connector.getBalance(this.address))) !== null && _a !== void 0 ? _a : '0';
+        });
+    }
+    /**
+     * Returns the Aleo public key for this wallet.
+     * In Aleo, the public key and address are the same value.
+     */
+    getPublicKey() {
+        return this.address;
+    }
+    /**
+     * Returns the current network this wallet is connected to (e.g. 'aleo:mainnet').
+     */
+    getNetworkInfo() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.getNetwork();
+        });
+    }
+    /**
+     * Signs a message with the Aleo wallet.
+     * Accepts both plain strings and Uint8Array (decoded to UTF-8).
+     */
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const messageString = typeof message === 'string' ? message : new TextDecoder().decode(message);
+            const signature = yield this._connector.signMessage(messageString);
+            if (!signature) {
+                throw new utils.DynamicError('Failed to sign message');
+            }
+            return signature;
+        });
+    }
+    /**
+     * Executes a program transition on the Aleo network.
+     * Returns the transaction ID on success.
+     *
+     * @param transaction - The transaction to execute
+     */
+    requestTransaction(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.requestTransaction(transaction);
+        });
+    }
+    /**
+     * Decrypts an Aleo ciphertext using the wallet's view key.
+     * Useful for reading private record data.
+     *
+     * @param ciphertext - The ciphertext string to decrypt
+     * @param options - Optional parameters (tpk, programId, functionName, index)
+     */
+    decrypt(ciphertext, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.decrypt(ciphertext, options);
+        });
+    }
+    /**
+     * Requests the records owned by this wallet for a given Aleo program.
+     *
+     * @param program - The program ID to fetch records for (e.g. 'credits.aleo')
+     * @param options - Optional: { plaintext: true } to return decrypted record data
+     */
+    requestRecords(program, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.requestRecords(program, options);
+        });
+    }
+}
+
+exports.AleoWallet = AleoWallet;

package/src/wallet/AleoWallet/AleoWallet.d.ts

@@ -0,0 +1,57 @@
+import { Wallet } from '@dynamic-labs/wallet-connector-core';
+import type { AleoWalletConnector } from '../../connectors/AleoWalletConnector';
+import type { AleoTransaction } from '../../types';
+export declare class AleoWallet extends Wallet<AleoWalletConnector> {
+    sendBalance({ amount, toAddress, token, }: {
+        amount: string;
+        toAddress: string;
+        token?: {
+            address: string;
+            decimals?: number;
+        };
+    }): Promise<string | undefined>;
+    getBalance(): Promise<string>;
+    /**
+     * Returns the Aleo public key for this wallet.
+     * In Aleo, the public key and address are the same value.
+     */
+    getPublicKey(): string;
+    /**
+     * Returns the current network this wallet is connected to (e.g. 'aleo:mainnet').
+     */
+    getNetworkInfo(): Promise<string | undefined>;
+    /**
+     * Signs a message with the Aleo wallet.
+     * Accepts both plain strings and Uint8Array (decoded to UTF-8).
+     */
+    signMessage(message: string | Uint8Array): Promise<string>;
+    /**
+     * Executes a program transition on the Aleo network.
+     * Returns the transaction ID on success.
+     *
+     * @param transaction - The transaction to execute
+     */
+    requestTransaction(transaction: AleoTransaction): Promise<string>;
+    /**
+     * Decrypts an Aleo ciphertext using the wallet's view key.
+     * Useful for reading private record data.
+     *
+     * @param ciphertext - The ciphertext string to decrypt
+     * @param options - Optional parameters (tpk, programId, functionName, index)
+     */
+    decrypt(ciphertext: string, options?: {
+        tpk?: string;
+        programId?: string;
+        functionName?: string;
+        index?: number;
+    }): Promise<string>;
+    /**
+     * Requests the records owned by this wallet for a given Aleo program.
+     *
+     * @param program - The program ID to fetch records for (e.g. 'credits.aleo')
+     * @param options - Optional: { plaintext: true } to return decrypted record data
+     */
+    requestRecords(program: string, options?: {
+        plaintext?: boolean;
+    }): Promise<unknown[]>;
+}