@dynamic-labs/aleo 4.79.2 → 4.80.0

package/src/connectors/DynamicWaasAleoConnector/index.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DynamicWaasAleoConnector = require('./DynamicWaasAleoConnector.cjs');
+
+const DynamicWaasAleoConnectors = () => [
+    DynamicWaasAleoConnector.DynamicWaasAleoConnector,
+];
+
+exports.DynamicWaasAleoConnector = DynamicWaasAleoConnector.DynamicWaasAleoConnector;
+exports.DynamicWaasAleoConnectors = DynamicWaasAleoConnectors;

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

@@ -0,0 +1,3 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+export * from './DynamicWaasAleoConnector';
+export declare const DynamicWaasAleoConnectors: () => WalletConnectorConstructor[];

package/src/connectors/DynamicWaasAleoConnector/index.js

@@ -0,0 +1,9 @@
+'use client'
+import { DynamicWaasAleoConnector } from './DynamicWaasAleoConnector.js';
+export { DynamicWaasAleoConnector } from './DynamicWaasAleoConnector.js';
+
+const DynamicWaasAleoConnectors = () => [
+    DynamicWaasAleoConnector,
+];
+
+export { DynamicWaasAleoConnectors };

package/src/connectors/WaasAleoWalletConnector/WaasAleoWalletConnector.cjs

@@ -0,0 +1,216 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var aleoTypes = require('@provablehq/aleo-types');
+var logger = require('@dynamic-labs/logger');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var AleoWallet = require('../../wallet/AleoWallet/AleoWallet.cjs');
+var fetchPublicBalance = require('../../utils/fetchPublicBalance/fetchPublicBalance.cjs');
+var getNetworkByChainId = require('../../utils/getNetworkByChainId/getNetworkByChainId.cjs');
+
+const MICROCREDITS_PER_CREDIT = 1000000;
+/**
+ * localStorage key for the user-selected Aleo chainId. Mirrors the pattern
+ * used by `DYNAMIC_SVM_NETWORK_ID_LS_KEY` in `@dynamic-labs/solana-core` and
+ * the equivalent EVM key — gives WaaS Aleo wallets the same persisted-network
+ * UX as the other chains.
+ */
+const DYNAMIC_ALEO_NETWORK_ID_LS_KEY = 'dynamic_aleo_network_id';
+/**
+ * Abstract WaaS-side base connector for Aleo.
+ * Does NOT depend on the @provablehq/aleo-wallet-standard StandardWallet
+ * (that's only relevant for injected browser wallets like Leo/Puzzle/Fox).
+ * The concrete Dynamic WaaS connector extends this via `withDynamicWaas`.
+ */
+class WaasAleoWalletConnector extends walletConnectorCore.WalletConnectorBase {
+    constructor(name, opts) {
+        var _a;
+        super({
+            metadata: opts.metadata,
+            walletBook: opts.walletBook,
+        });
+        this.ChainWallet = AleoWallet.AleoWallet;
+        this.name = 'Waas Aleo Wallet';
+        this.connectedChain = 'ALEO';
+        this.supportedChains = ['ALEO'];
+        this.name = name;
+        this.logger = new logger.Logger(this.name);
+        this.aleoNetworks = (_a = opts.aleoNetworks) !== null && _a !== void 0 ? _a : [];
+        this.overrideKey = this.key;
+    }
+    // ---------------------------------------------------------------------------
+    // Network selection (mirrors EVM/Solana Turnkey patterns)
+    //
+    //   localStorage value (set via switchNetwork) → getSelectedNetwork
+    //                       ↓ if absent
+    //                   default fallback (testnet-prefer for sandbox)
+    //
+    // Persisting in localStorage keeps the widget's network across reloads and
+    // keeps parity with how EVM/SVM Turnkey connectors track selectedNetwork.
+    // ---------------------------------------------------------------------------
+    /**
+     * Reads the user's selected network chainId from localStorage. Returns ''
+     * if nothing is stored (matches Solana Turnkey's pattern). Callers should
+     * fall back to a default when this is empty.
+     */
+    getNetworkId() {
+        var _a;
+        if (typeof globalThis === 'undefined' || !globalThis.localStorage) {
+            return '';
+        }
+        return ((_a = globalThis.localStorage.getItem(DYNAMIC_ALEO_NETWORK_ID_LS_KEY)) !== null && _a !== void 0 ? _a : '');
+    }
+    /**
+     * Writes the selected network chainId to localStorage. Pass `null` to
+     * clear (e.g. on logout). Same shape as EVM/Solana Turnkey.
+     */
+    setNetworkId(networkId) {
+        if (typeof globalThis === 'undefined' || !globalThis.localStorage) {
+            return;
+        }
+        if (networkId === null || networkId === '') {
+            globalThis.localStorage.removeItem(DYNAMIC_ALEO_NETWORK_ID_LS_KEY);
+        }
+        else {
+            globalThis.localStorage.setItem(DYNAMIC_ALEO_NETWORK_ID_LS_KEY, networkId);
+        }
+    }
+    /**
+     * Returns the currently-selected network entry from `aleoNetworks`.
+     *
+     * Resolution order:
+     *   1. localStorage value (set by `setNetworkId` / `switchNetwork`)
+     *   2. First entry in `aleoNetworks` — this is the env's default ordering
+     *      (matches how `TurnkeyEVMWalletConnector.getLastUsedChainId` falls
+     *      back to `evmNetworks[0].chainId`). Crucially, if we returned a
+     *      different network than the env's default, the widget's network-
+     *      mismatch detector would flag the wallet as being on the wrong
+     *      chain and replace the chain pill with a "Switch Network" button.
+     *
+     * Returns undefined only if no networks are configured at all.
+     *
+     * Note: when an env enables both mainnet + testnet (e.g. some sandbox
+     * configs), the user can call `switchNetwork({ networkChainId: 1 })` to
+     * land on testnet; the choice is persisted in localStorage and survives
+     * reloads.
+     */
+    getSelectedNetwork() {
+        if (this.aleoNetworks.length === 0)
+            return undefined;
+        const stored = this.getNetworkId();
+        if (stored) {
+            const match = this.aleoNetworks.find((n) => String(n.chainId) === stored);
+            if (match)
+                return match;
+        }
+        return this.aleoNetworks[0];
+    }
+    /**
+     * Resolves the current Aleo `Network` enum (used internally by
+     * `fetchPublicBalance`). Falls back to TESTNET if nothing's configured.
+     * Protected so WaaS subclasses can reuse the same selected-network for
+     * widget flows (e.g. AleoUiTransaction.getBalance).
+     */
+    resolveNetwork() {
+        var _a, _b;
+        const entry = this.getSelectedNetwork();
+        const chainId = typeof (entry === null || entry === void 0 ? void 0 : entry.chainId) === 'number'
+            ? entry.chainId
+            : Number((_a = entry === null || entry === void 0 ? void 0 : entry.chainId) !== null && _a !== void 0 ? _a : NaN);
+        return ((_b = (Number.isFinite(chainId) ? getNetworkByChainId.getNetworkByChainId(chainId) : undefined)) !== null && _b !== void 0 ? _b : aleoTypes.Network.TESTNET);
+    }
+    /**
+     * Returns the active network's chainId as a STRING.
+     *
+     * dynamic-auth's `useWalletConnectorNetwork` hook explicitly treats Aleo
+     * (alongside STARK and STELLAR) as a string-chainId chain — see the
+     * `useChainAsString` switch. Returning a number causes downstream
+     * comparisons and the chainChange event handler to mis-parse, leaving the
+     * widget in a perpetual loading-skeleton state.
+     *
+     * Returning `'0'` or `'1'` matches the format consumers expect, while
+     * `resolveNetworkIdForRequest` happily coerces `'1'` back to `1` for the
+     * balance API call.
+     */
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const entry = this.getSelectedNetwork();
+            if ((entry === null || entry === void 0 ? void 0 : entry.chainId) === undefined || (entry === null || entry === void 0 ? void 0 : entry.chainId) === null) {
+                return undefined;
+            }
+            return String(entry.chainId);
+        });
+    }
+    /**
+     * Indicates this connector supports user-driven network switching, so the
+     * widget UI exposes the chain-switcher dropdown for Aleo wallets.
+     */
+    supportsNetworkSwitching() {
+        return true;
+    }
+    /**
+     * Returns the env-configured Aleo networks. The widget's NetworkPicker
+     * uses this to render the chain-switcher dropdown and to decide whether
+     * the wallet's current network is "supported". Without overriding this,
+     * the base class returns `[]` and the widget renders a red "Switch Network"
+     * button (because no network in the empty list matches `getNetwork()`'s
+     * value).
+     *
+     * Mirrors `AleoWalletConnector.getEnabledNetworks()` from the external-
+     * wallet path.
+     */
+    getEnabledNetworks() {
+        return this.aleoNetworks;
+    }
+    /**
+     * Switches the active Aleo network. Persists the selection in localStorage
+     * and emits `chainChange` so the widget / DApp can react. Mirrors the
+     * EVM/SVM Turnkey switchNetwork flow.
+     */
+    switchNetwork(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ networkChainId, }) {
+            if (networkChainId === undefined ||
+                networkChainId === null ||
+                networkChainId === '') {
+                return;
+            }
+            const chainIdString = String(networkChainId);
+            // Validate the chainId is one we actually have configured before persisting.
+            const target = this.aleoNetworks.find((n) => String(n.chainId) === chainIdString);
+            if (!target) {
+                this.logger.warn(`[switchNetwork] chainId ${chainIdString} not in configured aleoNetworks`);
+                return;
+            }
+            this.setNetworkId(chainIdString);
+            this.emit('chainChange', { chain: chainIdString });
+        });
+    }
+    /**
+     * Returns the wallet's public credits balance as a human-readable credits
+     * string (e.g. "0.5" = 0.5 credits = 500,000 microcredits).
+     * Matches the format used by AleoWalletAdapterConnector.getBalance so the
+     * widget UI renders WaaS Aleo wallets identically to external Aleo wallets.
+     */
+    getBalance(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const targetAddress = address !== null && address !== void 0 ? address : (yield this.getAddress());
+            if (!targetAddress) {
+                return undefined;
+            }
+            try {
+                const microcredits = yield fetchPublicBalance.fetchPublicBalance(targetAddress, this.resolveNetwork());
+                return (Number(microcredits) / MICROCREDITS_PER_CREDIT).toFixed(6);
+            }
+            catch (error) {
+                this.logger.debug('Failed to fetch Aleo public balance', error);
+                return undefined;
+            }
+        });
+    }
+}
+
+exports.DYNAMIC_ALEO_NETWORK_ID_LS_KEY = DYNAMIC_ALEO_NETWORK_ID_LS_KEY;
+exports.WaasAleoWalletConnector = WaasAleoWalletConnector;

package/src/connectors/WaasAleoWalletConnector/WaasAleoWalletConnector.d.ts

@@ -0,0 +1,116 @@
+import { Network } from '@provablehq/aleo-types';
+import { Logger } from '@dynamic-labs/logger';
+import type { GenericNetwork } from '@dynamic-labs/types';
+import { type Chain, WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { AleoWallet } from '../../wallet/AleoWallet';
+/**
+ * localStorage key for the user-selected Aleo chainId. Mirrors the pattern
+ * used by `DYNAMIC_SVM_NETWORK_ID_LS_KEY` in `@dynamic-labs/solana-core` and
+ * the equivalent EVM key — gives WaaS Aleo wallets the same persisted-network
+ * UX as the other chains.
+ */
+export declare const DYNAMIC_ALEO_NETWORK_ID_LS_KEY = "dynamic_aleo_network_id";
+export type WaasAleoWalletConnectorProps = {
+    metadata?: unknown;
+    aleoNetworks?: GenericNetwork[];
+    walletBook: unknown;
+};
+/**
+ * Abstract WaaS-side base connector for Aleo.
+ * Does NOT depend on the @provablehq/aleo-wallet-standard StandardWallet
+ * (that's only relevant for injected browser wallets like Leo/Puzzle/Fox).
+ * The concrete Dynamic WaaS connector extends this via `withDynamicWaas`.
+ */
+export declare abstract class WaasAleoWalletConnector extends WalletConnectorBase<typeof AleoWallet> {
+    ChainWallet: typeof AleoWallet;
+    name: string;
+    connectedChain: Chain;
+    readonly supportedChains: Chain[];
+    protected aleoNetworks: GenericNetwork[];
+    logger: Logger;
+    constructor(name: string, opts: WaasAleoWalletConnectorProps);
+    /**
+     * Reads the user's selected network chainId from localStorage. Returns ''
+     * if nothing is stored (matches Solana Turnkey's pattern). Callers should
+     * fall back to a default when this is empty.
+     */
+    getNetworkId(): string;
+    /**
+     * Writes the selected network chainId to localStorage. Pass `null` to
+     * clear (e.g. on logout). Same shape as EVM/Solana Turnkey.
+     */
+    setNetworkId(networkId: string | null): void;
+    /**
+     * Returns the currently-selected network entry from `aleoNetworks`.
+     *
+     * Resolution order:
+     *   1. localStorage value (set by `setNetworkId` / `switchNetwork`)
+     *   2. First entry in `aleoNetworks` — this is the env's default ordering
+     *      (matches how `TurnkeyEVMWalletConnector.getLastUsedChainId` falls
+     *      back to `evmNetworks[0].chainId`). Crucially, if we returned a
+     *      different network than the env's default, the widget's network-
+     *      mismatch detector would flag the wallet as being on the wrong
+     *      chain and replace the chain pill with a "Switch Network" button.
+     *
+     * Returns undefined only if no networks are configured at all.
+     *
+     * Note: when an env enables both mainnet + testnet (e.g. some sandbox
+     * configs), the user can call `switchNetwork({ networkChainId: 1 })` to
+     * land on testnet; the choice is persisted in localStorage and survives
+     * reloads.
+     */
+    getSelectedNetwork(): GenericNetwork | undefined;
+    /**
+     * Resolves the current Aleo `Network` enum (used internally by
+     * `fetchPublicBalance`). Falls back to TESTNET if nothing's configured.
+     * Protected so WaaS subclasses can reuse the same selected-network for
+     * widget flows (e.g. AleoUiTransaction.getBalance).
+     */
+    protected resolveNetwork(): Network;
+    /**
+     * Returns the active network's chainId as a STRING.
+     *
+     * dynamic-auth's `useWalletConnectorNetwork` hook explicitly treats Aleo
+     * (alongside STARK and STELLAR) as a string-chainId chain — see the
+     * `useChainAsString` switch. Returning a number causes downstream
+     * comparisons and the chainChange event handler to mis-parse, leaving the
+     * widget in a perpetual loading-skeleton state.
+     *
+     * Returning `'0'` or `'1'` matches the format consumers expect, while
+     * `resolveNetworkIdForRequest` happily coerces `'1'` back to `1` for the
+     * balance API call.
+     */
+    getNetwork(): Promise<string | undefined>;
+    /**
+     * Indicates this connector supports user-driven network switching, so the
+     * widget UI exposes the chain-switcher dropdown for Aleo wallets.
+     */
+    supportsNetworkSwitching(): boolean;
+    /**
+     * Returns the env-configured Aleo networks. The widget's NetworkPicker
+     * uses this to render the chain-switcher dropdown and to decide whether
+     * the wallet's current network is "supported". Without overriding this,
+     * the base class returns `[]` and the widget renders a red "Switch Network"
+     * button (because no network in the empty list matches `getNetwork()`'s
+     * value).
+     *
+     * Mirrors `AleoWalletConnector.getEnabledNetworks()` from the external-
+     * wallet path.
+     */
+    getEnabledNetworks(): GenericNetwork[];
+    /**
+     * Switches the active Aleo network. Persists the selection in localStorage
+     * and emits `chainChange` so the widget / DApp can react. Mirrors the
+     * EVM/SVM Turnkey switchNetwork flow.
+     */
+    switchNetwork({ networkChainId, }: {
+        networkChainId: number | string | undefined;
+    }): Promise<void>;
+    /**
+     * Returns the wallet's public credits balance as a human-readable credits
+     * string (e.g. "0.5" = 0.5 credits = 500,000 microcredits).
+     * Matches the format used by AleoWalletAdapterConnector.getBalance so the
+     * widget UI renders WaaS Aleo wallets identically to external Aleo wallets.
+     */
+    getBalance(address?: string): Promise<string | undefined>;
+}

package/src/connectors/WaasAleoWalletConnector/WaasAleoWalletConnector.js

@@ -0,0 +1,211 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Network } from '@provablehq/aleo-types';
+import { Logger } from '@dynamic-labs/logger';
+import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { AleoWallet } from '../../wallet/AleoWallet/AleoWallet.js';
+import { fetchPublicBalance } from '../../utils/fetchPublicBalance/fetchPublicBalance.js';
+import { getNetworkByChainId } from '../../utils/getNetworkByChainId/getNetworkByChainId.js';
+
+const MICROCREDITS_PER_CREDIT = 1000000;
+/**
+ * localStorage key for the user-selected Aleo chainId. Mirrors the pattern
+ * used by `DYNAMIC_SVM_NETWORK_ID_LS_KEY` in `@dynamic-labs/solana-core` and
+ * the equivalent EVM key — gives WaaS Aleo wallets the same persisted-network
+ * UX as the other chains.
+ */
+const DYNAMIC_ALEO_NETWORK_ID_LS_KEY = 'dynamic_aleo_network_id';
+/**
+ * Abstract WaaS-side base connector for Aleo.
+ * Does NOT depend on the @provablehq/aleo-wallet-standard StandardWallet
+ * (that's only relevant for injected browser wallets like Leo/Puzzle/Fox).
+ * The concrete Dynamic WaaS connector extends this via `withDynamicWaas`.
+ */
+class WaasAleoWalletConnector extends WalletConnectorBase {
+    constructor(name, opts) {
+        var _a;
+        super({
+            metadata: opts.metadata,
+            walletBook: opts.walletBook,
+        });
+        this.ChainWallet = AleoWallet;
+        this.name = 'Waas Aleo Wallet';
+        this.connectedChain = 'ALEO';
+        this.supportedChains = ['ALEO'];
+        this.name = name;
+        this.logger = new Logger(this.name);
+        this.aleoNetworks = (_a = opts.aleoNetworks) !== null && _a !== void 0 ? _a : [];
+        this.overrideKey = this.key;
+    }
+    // ---------------------------------------------------------------------------
+    // Network selection (mirrors EVM/Solana Turnkey patterns)
+    //
+    //   localStorage value (set via switchNetwork) → getSelectedNetwork
+    //                       ↓ if absent
+    //                   default fallback (testnet-prefer for sandbox)
+    //
+    // Persisting in localStorage keeps the widget's network across reloads and
+    // keeps parity with how EVM/SVM Turnkey connectors track selectedNetwork.
+    // ---------------------------------------------------------------------------
+    /**
+     * Reads the user's selected network chainId from localStorage. Returns ''
+     * if nothing is stored (matches Solana Turnkey's pattern). Callers should
+     * fall back to a default when this is empty.
+     */
+    getNetworkId() {
+        var _a;
+        if (typeof globalThis === 'undefined' || !globalThis.localStorage) {
+            return '';
+        }
+        return ((_a = globalThis.localStorage.getItem(DYNAMIC_ALEO_NETWORK_ID_LS_KEY)) !== null && _a !== void 0 ? _a : '');
+    }
+    /**
+     * Writes the selected network chainId to localStorage. Pass `null` to
+     * clear (e.g. on logout). Same shape as EVM/Solana Turnkey.
+     */
+    setNetworkId(networkId) {
+        if (typeof globalThis === 'undefined' || !globalThis.localStorage) {
+            return;
+        }
+        if (networkId === null || networkId === '') {
+            globalThis.localStorage.removeItem(DYNAMIC_ALEO_NETWORK_ID_LS_KEY);
+        }
+        else {
+            globalThis.localStorage.setItem(DYNAMIC_ALEO_NETWORK_ID_LS_KEY, networkId);
+        }
+    }
+    /**
+     * Returns the currently-selected network entry from `aleoNetworks`.
+     *
+     * Resolution order:
+     *   1. localStorage value (set by `setNetworkId` / `switchNetwork`)
+     *   2. First entry in `aleoNetworks` — this is the env's default ordering
+     *      (matches how `TurnkeyEVMWalletConnector.getLastUsedChainId` falls
+     *      back to `evmNetworks[0].chainId`). Crucially, if we returned a
+     *      different network than the env's default, the widget's network-
+     *      mismatch detector would flag the wallet as being on the wrong
+     *      chain and replace the chain pill with a "Switch Network" button.
+     *
+     * Returns undefined only if no networks are configured at all.
+     *
+     * Note: when an env enables both mainnet + testnet (e.g. some sandbox
+     * configs), the user can call `switchNetwork({ networkChainId: 1 })` to
+     * land on testnet; the choice is persisted in localStorage and survives
+     * reloads.
+     */
+    getSelectedNetwork() {
+        if (this.aleoNetworks.length === 0)
+            return undefined;
+        const stored = this.getNetworkId();
+        if (stored) {
+            const match = this.aleoNetworks.find((n) => String(n.chainId) === stored);
+            if (match)
+                return match;
+        }
+        return this.aleoNetworks[0];
+    }
+    /**
+     * Resolves the current Aleo `Network` enum (used internally by
+     * `fetchPublicBalance`). Falls back to TESTNET if nothing's configured.
+     * Protected so WaaS subclasses can reuse the same selected-network for
+     * widget flows (e.g. AleoUiTransaction.getBalance).
+     */
+    resolveNetwork() {
+        var _a, _b;
+        const entry = this.getSelectedNetwork();
+        const chainId = typeof (entry === null || entry === void 0 ? void 0 : entry.chainId) === 'number'
+            ? entry.chainId
+            : Number((_a = entry === null || entry === void 0 ? void 0 : entry.chainId) !== null && _a !== void 0 ? _a : NaN);
+        return ((_b = (Number.isFinite(chainId) ? getNetworkByChainId(chainId) : undefined)) !== null && _b !== void 0 ? _b : Network.TESTNET);
+    }
+    /**
+     * Returns the active network's chainId as a STRING.
+     *
+     * dynamic-auth's `useWalletConnectorNetwork` hook explicitly treats Aleo
+     * (alongside STARK and STELLAR) as a string-chainId chain — see the
+     * `useChainAsString` switch. Returning a number causes downstream
+     * comparisons and the chainChange event handler to mis-parse, leaving the
+     * widget in a perpetual loading-skeleton state.
+     *
+     * Returning `'0'` or `'1'` matches the format consumers expect, while
+     * `resolveNetworkIdForRequest` happily coerces `'1'` back to `1` for the
+     * balance API call.
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entry = this.getSelectedNetwork();
+            if ((entry === null || entry === void 0 ? void 0 : entry.chainId) === undefined || (entry === null || entry === void 0 ? void 0 : entry.chainId) === null) {
+                return undefined;
+            }
+            return String(entry.chainId);
+        });
+    }
+    /**
+     * Indicates this connector supports user-driven network switching, so the
+     * widget UI exposes the chain-switcher dropdown for Aleo wallets.
+     */
+    supportsNetworkSwitching() {
+        return true;
+    }
+    /**
+     * Returns the env-configured Aleo networks. The widget's NetworkPicker
+     * uses this to render the chain-switcher dropdown and to decide whether
+     * the wallet's current network is "supported". Without overriding this,
+     * the base class returns `[]` and the widget renders a red "Switch Network"
+     * button (because no network in the empty list matches `getNetwork()`'s
+     * value).
+     *
+     * Mirrors `AleoWalletConnector.getEnabledNetworks()` from the external-
+     * wallet path.
+     */
+    getEnabledNetworks() {
+        return this.aleoNetworks;
+    }
+    /**
+     * Switches the active Aleo network. Persists the selection in localStorage
+     * and emits `chainChange` so the widget / DApp can react. Mirrors the
+     * EVM/SVM Turnkey switchNetwork flow.
+     */
+    switchNetwork(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ networkChainId, }) {
+            if (networkChainId === undefined ||
+                networkChainId === null ||
+                networkChainId === '') {
+                return;
+            }
+            const chainIdString = String(networkChainId);
+            // Validate the chainId is one we actually have configured before persisting.
+            const target = this.aleoNetworks.find((n) => String(n.chainId) === chainIdString);
+            if (!target) {
+                this.logger.warn(`[switchNetwork] chainId ${chainIdString} not in configured aleoNetworks`);
+                return;
+            }
+            this.setNetworkId(chainIdString);
+            this.emit('chainChange', { chain: chainIdString });
+        });
+    }
+    /**
+     * Returns the wallet's public credits balance as a human-readable credits
+     * string (e.g. "0.5" = 0.5 credits = 500,000 microcredits).
+     * Matches the format used by AleoWalletAdapterConnector.getBalance so the
+     * widget UI renders WaaS Aleo wallets identically to external Aleo wallets.
+     */
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetAddress = address !== null && address !== void 0 ? address : (yield this.getAddress());
+            if (!targetAddress) {
+                return undefined;
+            }
+            try {
+                const microcredits = yield fetchPublicBalance(targetAddress, this.resolveNetwork());
+                return (Number(microcredits) / MICROCREDITS_PER_CREDIT).toFixed(6);
+            }
+            catch (error) {
+                this.logger.debug('Failed to fetch Aleo public balance', error);
+                return undefined;
+            }
+        });
+    }
+}
+
+export { DYNAMIC_ALEO_NETWORK_ID_LS_KEY, WaasAleoWalletConnector };

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

@@ -0,0 +1 @@
+export * from './WaasAleoWalletConnector';

package/src/index.cjs

@@ -6,20 +6,29 @@ 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 index = require('./connectors/DynamicWaasAleoConnector/index.cjs');
 var AleoWalletConnector = require('./connectors/AleoWalletConnector/AleoWalletConnector.cjs');
 var AleoWalletAdapterConnector = require('./connectors/AleoWalletAdapterConnector/AleoWalletAdapterConnector.cjs');
+var WaasAleoWalletConnector = require('./connectors/WaasAleoWalletConnector/WaasAleoWalletConnector.cjs');
 var isAleoWallet = require('./wallet/isAleoWallet/isAleoWallet.cjs');
+var AleoUiTransaction = require('./utils/AleoUiTransaction/AleoUiTransaction.cjs');
 var aleoWalletStandard = require('@provablehq/aleo-wallet-standard');
+var aleoSendableTokens = require('./utils/aleoSendableTokens/aleoSendableTokens.cjs');
+var DynamicWaasAleoConnector = require('./connectors/DynamicWaasAleoConnector/DynamicWaasAleoConnector.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/aleo', _package.version);
 const AleoWalletConnectors = (props) => [
     // ...fetchAleoWalletConnectors(props),
     ...fetchAleoWalletAdapterConnectors.fetchAleoWalletAdapterConnectors(props),
+    ...index.DynamicWaasAleoConnectors(),
 ];
 
+exports.DynamicWaasAleoConnectors = index.DynamicWaasAleoConnectors;
 exports.AleoWalletConnector = AleoWalletConnector.AleoWalletConnector;
 exports.AleoWalletAdapterConnector = AleoWalletAdapterConnector.AleoWalletAdapterConnector;
+exports.WaasAleoWalletConnector = WaasAleoWalletConnector.WaasAleoWalletConnector;
 exports.isAleoWallet = isAleoWallet.isAleoWallet;
+exports.AleoUiTransaction = AleoUiTransaction.AleoUiTransaction;
 Object.defineProperty(exports, 'ALEO_CHAINS', {
   enumerable: true,
   get: function () { return aleoWalletStandard.ALEO_CHAINS; }
@@ -36,4 +45,10 @@ Object.defineProperty(exports, 'WalletReadyState', {
   enumerable: true,
   get: function () { return aleoWalletStandard.WalletReadyState; }
 });
+exports.ALEO_CREDITS_PROGRAM = aleoSendableTokens.ALEO_CREDITS_PROGRAM;
+exports.ALEO_TOKEN_REGISTRY_PROGRAM = aleoSendableTokens.ALEO_TOKEN_REGISTRY_PROGRAM;
+exports.extractRecordAtomicAmount = aleoSendableTokens.extractRecordAtomicAmount;
+exports.getAleoSendableTokensForNetwork = aleoSendableTokens.getAleoSendableTokensForNetwork;
+exports.recordMatchesSendableToken = aleoSendableTokens.recordMatchesSendableToken;
+exports.DynamicWaasAleoConnector = DynamicWaasAleoConnector.DynamicWaasAleoConnector;
 exports.AleoWalletConnectors = AleoWalletConnectors;

package/src/index.d.ts

@@ -4,10 +4,15 @@ 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 { DynamicWaasAleoConnector, DynamicWaasAleoConnectors, } from './connectors/DynamicWaasAleoConnector';
+export { WaasAleoWalletConnector } from './connectors/WaasAleoWalletConnector';
 export { isAleoWallet } from './wallet/isAleoWallet';
+export { AleoUiTransaction } from './utils/AleoUiTransaction';
 export type { AleoTransaction, AleoTransition } from './types';
 export { ALEO_CHAINS, WalletDecryptPermission, WalletFeatureName, WalletReadyState, } from './types';
 export type { AleoChain, StandardWallet } from './types';
+export { ALEO_CREDITS_PROGRAM, ALEO_TOKEN_REGISTRY_PROGRAM, extractRecordAtomicAmount, getAleoSendableTokensForNetwork, recordMatchesSendableToken, } from './utils/aleoSendableTokens/aleoSendableTokens';
+export type { AleoOwnedRecord, AleoProgramKind, AleoSendableToken, } from './utils/aleoSendableTokens/aleoSendableTokens';
 export declare const AleoWalletConnectors: (props: {
     walletBook: WalletBookSchema;
     aleoNetworks: GenericNetwork[];

package/src/index.js

@@ -2,15 +2,22 @@
 import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
 import { version } from '../package.js';
 import { fetchAleoWalletAdapterConnectors } from './utils/fetchAleoWalletAdapterConnectors/fetchAleoWalletAdapterConnectors.js';
+import { DynamicWaasAleoConnectors } from './connectors/DynamicWaasAleoConnector/index.js';
+export { DynamicWaasAleoConnectors } from './connectors/DynamicWaasAleoConnector/index.js';
 export { AleoWalletConnector } from './connectors/AleoWalletConnector/AleoWalletConnector.js';
 export { AleoWalletAdapterConnector } from './connectors/AleoWalletAdapterConnector/AleoWalletAdapterConnector.js';
+export { WaasAleoWalletConnector } from './connectors/WaasAleoWalletConnector/WaasAleoWalletConnector.js';
 export { isAleoWallet } from './wallet/isAleoWallet/isAleoWallet.js';
+export { AleoUiTransaction } from './utils/AleoUiTransaction/AleoUiTransaction.js';
 export { ALEO_CHAINS, WalletDecryptPermission, WalletFeatureName, WalletReadyState } from '@provablehq/aleo-wallet-standard';
+export { ALEO_CREDITS_PROGRAM, ALEO_TOKEN_REGISTRY_PROGRAM, extractRecordAtomicAmount, getAleoSendableTokensForNetwork, recordMatchesSendableToken } from './utils/aleoSendableTokens/aleoSendableTokens.js';
+export { DynamicWaasAleoConnector } from './connectors/DynamicWaasAleoConnector/DynamicWaasAleoConnector.js';
 
 assertPackageVersion('@dynamic-labs/aleo', version);
 const AleoWalletConnectors = (props) => [
     // ...fetchAleoWalletConnectors(props),
     ...fetchAleoWalletAdapterConnectors(props),
+    ...DynamicWaasAleoConnectors(),
 ];
 
 export { AleoWalletConnectors };