@layerswap/wallet-starknet 1.7.0-next.1 → 2.0.0-next.0

package/dist/esm/constants.js

@@ -1,4 +1,4 @@
-import { KnownInternalNames } from "@layerswap/widget/internal";
+import { KnownInternalNames } from "@layerswap/utils";
 export const name = 'Starknet';
 export const id = 'starknet';
 export const starknetNames = [KnownInternalNames.Networks.StarkNetMainnet, KnownInternalNames.Networks.StarkNetSepolia, KnownInternalNames.Networks.StarkNetGoerli];

package/dist/esm/index.js

@@ -1,21 +1,29 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import StarknetProviderWrapper from "./StarknetProvider";
-import useStarknetConnection from "./useStarknetConnection";
+import { LazyGasProvider } from "@layerswap/widget-types";
+import { KnownInternalNames } from "@layerswap/utils";
 import { StarknetBalanceProvider } from "./starknetBalanceProvider";
-import { LazyGasProvider } from "@layerswap/widget/types";
-import { AppSettings, KnownInternalNames } from "@layerswap/widget/internal";
 import { StarknetNftProvider } from "./starknetNftProvider";
-import React from "react";
-import { useStarknetTransfer } from "./useStarknetTransfer";
+import { createStarknetTransfer } from "./transferProvider/createStarknetTransfer";
+import { createStarknetConnection } from "./service/createStarknetConnection";
+import { initStarknetProvider } from "./init";
+import { id } from "./constants";
 const isStarknetNetwork = (name) => KnownInternalNames.Networks.StarkNetMainnet.includes(name) ||
     KnownInternalNames.Networks.StarkNetGoerli.includes(name) ||
     KnownInternalNames.Networks.StarkNetSepolia.includes(name);
-export { default as useStarknetConnection } from "./useStarknetConnection";
+// The literal id in the return type lets `defineWalletDescriptor` in
+// `@layerswap/wallets` verify it matches the descriptor id at compile time.
 export function createStarknetProvider(config = {}) {
-    const { customHook, balanceProviders, gasProviders, nftProviders, transferProviders } = config;
-    // Use custom hook if provided, otherwise use default
-    const walletConnectionProvider = customHook || useStarknetConnection;
-    // Use custom providers if provided, otherwise use defaults
+    const { customConnection, balanceProviders, gasProviders, nftProviders, transferProviders, } = config;
+    const init = (_ctx) => {
+        initStarknetProvider();
+        // No-op disposer; init is idempotent across remounts.
+    };
+    const createConnection = (props) => {
+        initStarknetProvider();
+        if (customConnection) {
+            return customConnection(props);
+        }
+        return createStarknetConnection(props);
+    };
     const defaultBalanceProviders = [new StarknetBalanceProvider()];
     const finalBalanceProviders = balanceProviders !== undefined
         ? (Array.isArray(balanceProviders) ? balanceProviders : [balanceProviders])
@@ -30,34 +38,20 @@ export function createStarknetProvider(config = {}) {
     const finalNftProviders = nftProviders !== undefined
         ? (Array.isArray(nftProviders) ? nftProviders : [nftProviders])
         : defaultNftProviders;
-    const defaultTransferProviders = [useStarknetTransfer];
+    const defaultTransferProviders = [createStarknetTransfer];
     const finalTransferProviders = transferProviders !== undefined
         ? (Array.isArray(transferProviders) ? transferProviders : [transferProviders])
         : defaultTransferProviders;
     return {
-        id: "starknet",
-        wrapper: StarknetProviderWrapper,
-        walletConnectionProvider,
+        id,
+        init,
+        createConnection,
         gasProvider: finalGasProviders,
         balanceProvider: finalBalanceProviders,
         nftProvider: finalNftProviders,
         transferProvider: finalTransferProviders,
     };
 }
-/**
- * @deprecated Use createStarknetProvider() instead. This export will be removed in a future version.
- * Note: This uses default WalletConnect configuration provided to LayerswapProvider.
- */
-export const StarknetProvider = {
-    id: "starknet",
-    wrapper: ({ children }) => {
-        return (_jsx(StarknetProviderWrapper, { walletConnectConfigs: AppSettings.WalletConnectConfig, children: children }));
-    },
-    walletConnectionProvider: useStarknetConnection,
-    gasProvider: [
-        new LazyGasProvider((n) => isStarknetNetwork(n.name), () => import("./starknetGasProvider").then(m => new m.StarknetGasProvider()))
-    ],
-    balanceProvider: [new StarknetBalanceProvider()],
-    nftProvider: [new StarknetNftProvider()],
-    transferProvider: [useStarknetTransfer],
-};
+export { createStarknetConnection } from "./service/createStarknetConnection";
+export { useStarknetStore } from "./service/starknetStore";
+export { starknetConnectorManager } from "./service/starknetConnectorManager";

package/dist/esm/init.js

@@ -0,0 +1,100 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DiscoveryConnector_wallet, _DiscoveryConnector_store;
+import { Connector, ConnectorNotConnectedError, UserNotConnectedError } from '@starknet-react/core';
+import { starknetConnectorManager } from './service/starknetConnectorManager';
+let _initialized = false;
+let _loadPromise = null;
+class DiscoveryConnector extends Connector {
+    constructor(wallet, store) {
+        super();
+        _DiscoveryConnector_wallet.set(this, void 0);
+        _DiscoveryConnector_store.set(this, void 0);
+        __classPrivateFieldSet(this, _DiscoveryConnector_wallet, wallet, "f");
+        __classPrivateFieldSet(this, _DiscoveryConnector_store, store, "f");
+    }
+    get id() { return `${__classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").id}-mobile`; }
+    get icon() { return { dark: __classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").icon, light: __classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").icon }; }
+    get name() { return `${__classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").name} (mobile)`; }
+    available() { return true; }
+    connect() {
+        window.open(__classPrivateFieldGet(this, _DiscoveryConnector_wallet, "f").downloads[__classPrivateFieldGet(this, _DiscoveryConnector_store, "f")], '_blank');
+        return undefined;
+    }
+    get wallet() { throw new ConnectorNotConnectedError(); }
+    disconnect() { throw new UserNotConnectedError(); }
+    account() { throw new ConnectorNotConnectedError(); }
+    ready() { throw new Error('Method not implemented.'); }
+    chainId() { throw new Error('Method not implemented.'); }
+    request(_call) {
+        throw new Error('Method not implemented.');
+    }
+}
+_DiscoveryConnector_wallet = new WeakMap(), _DiscoveryConnector_store = new WeakMap();
+/**
+ * One-shot initialization of the Starknet connectors + manager.
+ * Safe to call multiple times — subsequent calls are no-ops.
+ */
+export function initStarknetProvider() {
+    if (_initialized || _loadPromise)
+        return;
+    if (typeof window === 'undefined')
+        return;
+    _loadPromise = (async () => {
+        // @ts-ignore
+        const injectedModule = await import('starknetkit/injected');
+        // @ts-ignore
+        const webWalletModule = await import('starknetkit/webwallet');
+        // @ts-ignore
+        const controllerModule = await import('starknetkit/controller');
+        const InjectedConnector = injectedModule.InjectedConnector;
+        const WebWalletConnector = webWalletModule.WebWalletConnector;
+        const ControllerConnector = controllerModule.ControllerConnector;
+        const isSafari = typeof window !== 'undefined'
+            ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent)
+            : false;
+        const isAndroid = !!navigator.userAgent.match(/Android/i);
+        const isIOS = !!navigator.userAgent.match(/iPhone|iPad|iPod/i);
+        const defaultConnectors = [];
+        if (!isSafari) {
+            defaultConnectors.push(new InjectedConnector({ options: { id: 'argentX' } }));
+            defaultConnectors.push(new InjectedConnector({ options: { id: 'keplr' } }));
+            defaultConnectors.push(new InjectedConnector({ options: { id: 'braavos' } }));
+            defaultConnectors.push(new InjectedConnector({ options: { id: 'xverse' } }));
+        }
+        if ((isAndroid || isIOS) && !defaultConnectors.some(c => c.id === 'braavos')) {
+            const starknet = (await import('@starknet-io/get-starknet-core')).default;
+            const discoverWallets = (await starknet.getDiscoveryWallets()).filter(w => {
+                return (isAndroid && w.downloads['android']) || (isIOS && w.downloads['ios']);
+            });
+            if (discoverWallets.length) {
+                defaultConnectors.push(...discoverWallets.map(w => new DiscoveryConnector(w, isAndroid ? 'android' : 'ios')));
+            }
+        }
+        defaultConnectors.push(new ControllerConnector());
+        defaultConnectors.push(new WebWalletConnector());
+        starknetConnectorManager.register(defaultConnectors);
+        _initialized = true;
+    })();
+    _loadPromise.catch((error) => {
+        // Reset so the next init call retries; without the log a failed
+        // connector import leaves Starknet silently missing from the modal.
+        console.error('[layerswap/wallets] Starknet provider initialization failed', error);
+        _loadPromise = null;
+    });
+}
+/** Visible for tests. Resets singleton init so a fresh init can run. */
+export function _resetStarknetInit() {
+    _initialized = false;
+    _loadPromise = null;
+    starknetConnectorManager.dispose();
+}

package/dist/esm/service/StarknetConnectionService.js

@@ -0,0 +1,355 @@
+import { walletIconResolver } from "@layerswap/wallet-core";
+import { name as PROVIDER_NAME, id as PROVIDER_ID } from '../constants';
+import { resolveStarknetWalletIcon } from '../utils';
+import { starknetConnectorManager } from './starknetConnectorManager';
+import { useStarknetStore } from './starknetStore';
+const connectorsConfigs = [
+    {
+        id: 'braavos',
+        name: 'Braavos',
+        installLink: 'https://chromewebstore.google.com/detail/braavos-starknet-wallet/jnlgamecbpmbajjfhmmmlhejkemejdma',
+    },
+    {
+        id: 'argentX',
+        name: 'Ready X',
+        installLink: 'https://chromewebstore.google.com/detail/argent-x-starknet-wallet/dlcobpjiigpikoobohmabehhmhfoodbb',
+    },
+    {
+        id: 'keplr',
+        name: 'Keplr',
+        installLink: 'https://chromewebstore.google.com/detail/keplr/dmkamcknogkgcdfhhbddcghachkejeap',
+    },
+    {
+        id: 'xverse',
+        name: 'Xverse Wallet',
+        installLink: 'https://chromewebstore.google.com/detail/xverse-bitcoin-crypto-wal/idnnbdplmphpflfnlkomgpfbpcgelopg',
+    },
+];
+/**
+ * Validate the RPC endpoint before handing it to `RpcProvider`. The signing
+ * `WalletAccount` is built on top of this provider, so a non-RPC scheme injected
+ * via a compromised settings response (e.g. `javascript:`/`data:`) must never
+ * reach it. We require a well-formed secure-transport URL rather than pinning a
+ * host allowlist, so legitimate network/infra changes don't break resolution.
+ */
+function assertSecureRpcUrl(url) {
+    if (!url)
+        throw new Error('Missing Starknet RPC node_url');
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`Invalid Starknet RPC URL: ${url}`);
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'wss:') {
+        throw new Error(`Untrusted Starknet RPC protocol: ${parsed.protocol}`);
+    }
+}
+export async function resolveStarknetWallet(props) {
+    const { name, connector, network, disconnectWallets, address, withdrawalSupportedNetworks, autofillSupportedNetworks, asSourceSupportedNetworks } = props;
+    try {
+        const walletChain = network?.chainId;
+        assertSecureRpcUrl(network?.rpcUrl);
+        const { RpcProvider, WalletAccount } = await import('starknet');
+        const rpcProvider = new RpcProvider({ nodeUrl: network.rpcUrl });
+        const walletAccount = new WalletAccount({ provider: rpcProvider, walletProvider: connector.wallet, address });
+        const accounts = await walletAccount.requestAccounts(true);
+        const account = accounts?.[0];
+        const configuredName = connectorsConfigs.find(c => c.id === connector.id)?.name;
+        const connectorName = configuredName ?? connector.name;
+        const wallet = {
+            id: connectorName,
+            displayName: `${connectorName} - Starknet`,
+            address: account,
+            addresses: [account],
+            chainId: walletChain || '',
+            icon: walletIconResolver(address, resolveStarknetWalletIcon({ icon: connector.icon })),
+            providerName: name,
+            metadata: {
+                starknetAccount: walletAccount,
+            },
+            isActive: true,
+            withdrawalSupportedNetworks,
+            disconnect: () => disconnectWallets(),
+            networkIcon: network?.icon,
+            autofillSupportedNetworks,
+            asSourceSupportedNetworks,
+        };
+        return wallet;
+    }
+    catch (e) {
+        console.warn(`Failed to initialize wallet for ${connector.name}:`, e);
+        return null;
+    }
+}
+function toStarknetChainHex(chainId) {
+    if (!chainId)
+        return undefined;
+    if (chainId.startsWith('0x') || chainId.startsWith('0X'))
+        return chainId.toLowerCase();
+    let hex = '';
+    for (let i = 0; i < chainId.length; i++) {
+        hex += chainId.charCodeAt(i).toString(16).padStart(2, '0');
+    }
+    return `0x${hex}`;
+}
+export class StarknetConnectionService {
+    constructor() {
+        this._networks = [];
+        this._networksKey = '';
+        this._restoringStoredWallets = false;
+        this._restoreAttempts = 0;
+        this._maxRestoreAttempts = 20;
+    }
+    setNetworks(networks, networkAdapter) {
+        const key = networks.map(network => networkAdapter.getId(network)).join('|');
+        if (this._networksKey === key)
+            return;
+        this._networks = networks;
+        this._networkAdapter = networkAdapter;
+        this._networksKey = key;
+        this.requestStoredWalletHydration();
+    }
+    getStarknetNetwork() {
+        const network = this._networks.find(item => this._networkAdapter?.isStarknetNetwork(item));
+        if (!network || !this._networkAdapter)
+            return undefined;
+        return {
+            id: this._networkAdapter.getId(network),
+            displayName: this._networkAdapter.getDisplayName(network),
+            chainId: this._networkAdapter.getChainId(network),
+            rpcUrl: this._networkAdapter.getRpcUrls(network)[0],
+            icon: this._networkAdapter.getIcon(network),
+        };
+    }
+    getProviderIcon() {
+        return this.getStarknetNetwork()?.icon;
+    }
+    connectorIsAvailable(connector) {
+        try {
+            return typeof connector.available !== 'function'
+                || Boolean(connector.available());
+        }
+        catch {
+            return false;
+        }
+    }
+    hasPendingStoredWallets() {
+        const state = useStarknetStore.getState();
+        const connectedAddresses = new Set(state.connectedWallets.map(wallet => wallet.address.toLowerCase()));
+        return Object.values(state.starknetAccounts || {}).some(address => !connectedAddresses.has(address.toLowerCase()));
+    }
+    /**
+     * Drops persisted Starknet accounts that we've repeatedly failed to
+     * resolve back to a connected wallet (e.g. the user switched accounts in
+     * the wallet, or the stored connector is no longer available). Without
+     * this they would stay "pending" forever and keep the retry loop alive.
+     */
+    clearStalePendingWallets() {
+        const state = useStarknetStore.getState();
+        const connectedAddresses = new Set(state.connectedWallets.map(wallet => wallet.address.toLowerCase()));
+        const stale = Object.values(state.starknetAccounts || {}).filter(address => !connectedAddresses.has(address.toLowerCase()));
+        for (const address of stale)
+            state.removeAccount(address);
+    }
+    requestStoredWalletHydration() {
+        if (typeof window === 'undefined' || this._restoreTimer || this._restoringStoredWallets)
+            return;
+        // Fresh trigger (e.g. networks just changed): allow a new bounded run.
+        this._restoreAttempts = 0;
+        const attemptHydration = async () => {
+            this._restoreTimer = undefined;
+            // Unconditional re-entrancy guard at the top: if a hydration is already
+            // in flight (e.g. a fresh setNetworks() scheduled another run), bail so
+            // we never run two hydrateStoredWallets() concurrently and duplicate entries.
+            if (this._restoringStoredWallets)
+                return;
+            if (!this.hasPendingStoredWallets()) {
+                this._restoreAttempts = 0;
+                return;
+            }
+            if (this.getStarknetNetwork()) {
+                this._restoringStoredWallets = true;
+                try {
+                    await this.hydrateStoredWallets();
+                }
+                finally {
+                    this._restoringStoredWallets = false;
+                }
+            }
+            if (!this.hasPendingStoredWallets()) {
+                this._restoreAttempts = 0;
+                return;
+            }
+            // Still pending after this attempt. Bound the retry so a stale or
+            // unresolvable persisted account can't wake the page every 500ms
+            // for its entire lifetime. After the cap, drop the stale entries.
+            this._restoreAttempts += 1;
+            if (this._restoreAttempts >= this._maxRestoreAttempts) {
+                this.clearStalePendingWallets();
+                this._restoreAttempts = 0;
+                return;
+            }
+            this._restoreTimer = window.setTimeout(() => {
+                void attemptHydration();
+            }, 500);
+        };
+        this._restoreTimer = window.setTimeout(() => {
+            void attemptHydration();
+        }, 0);
+    }
+    dispose() {
+        if (this._restoreTimer) {
+            window.clearTimeout(this._restoreTimer);
+            this._restoreTimer = undefined;
+        }
+        this._restoringStoredWallets = false;
+    }
+    getAvailableConnectors() {
+        const connectors = useStarknetStore.getState().connectors;
+        return connectors.map(connector => {
+            const config = connectorsConfigs.find(c => c.id === connector.id);
+            const displayName = config?.name ?? connector.name;
+            const realConnector = starknetConnectorManager.getConnector(connector.id);
+            let isInjectedAndAvailable = false;
+            try {
+                isInjectedAndAvailable = !!config
+                    && typeof realConnector?.available === 'function'
+                    && realConnector.available();
+            }
+            catch {
+                isInjectedAndAvailable = false;
+            }
+            return {
+                name: displayName,
+                id: connector.id,
+                icon: resolveStarknetWalletIcon({ icon: connector.icon }),
+                type: isInjectedAndAvailable ? 'injected' : 'other',
+                installUrl: config?.installLink,
+                extensionNotFound: !!config?.installLink && !isInjectedAndAvailable,
+                providerName: displayName,
+            };
+        });
+    }
+    async disconnectWallets(_connectorName, address) {
+        try {
+            await starknetConnectorManager.disconnectAll();
+            if (address)
+                useStarknetStore.getState().removeAccount(address);
+        }
+        catch (e) {
+            // Disconnect is best-effort — log but do not rethrow.
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[Starknet] Failed to disconnect wallet: ${msg}`);
+        }
+    }
+    async connectWallet({ connector }) {
+        const starknetConnector = starknetConnectorManager.getConnector(connector.id);
+        if (!starknetConnector)
+            throw new Error('Connector not found');
+        let result = await starknetConnector.connect({});
+        const starknetNetwork = this.getStarknetNetwork();
+        if (!starknetNetwork)
+            throw new Error('Starknet network not found');
+        const walletChain = `0x${result?.chainId?.toString(16)}`;
+        const expectedChain = toStarknetChainHex(String(starknetNetwork.chainId ?? ''));
+        const wrongChain = !!expectedChain && walletChain !== expectedChain;
+        const networkDisplayName = starknetNetwork.displayName || starknetNetwork.id;
+        if (result?.account && wrongChain) {
+            const wallet = starknetConnector?._wallet || starknetConnector?.wallet;
+            if (wallet?.request) {
+                try {
+                    await wallet.request({
+                        type: 'wallet_switchStarknetChain',
+                        params: { chainId: expectedChain },
+                    });
+                    result = await starknetConnector.connect({});
+                }
+                catch (switchError) {
+                    console.log('Chain switch failed:', switchError);
+                    await this.disconnectWallets(connector?.name, result?.account);
+                    throw new Error(`Failed to switch network. Please switch manually to ${networkDisplayName} in your wallet.`);
+                }
+            }
+            else {
+                await this.disconnectWallets(connector?.name, result?.account);
+                throw new Error(`Please switch the network in your wallet to ${networkDisplayName} and connect again.`);
+            }
+        }
+        if (!result?.account)
+            return undefined;
+        const store = useStarknetStore.getState();
+        const resolvedWallet = await resolveStarknetWallet({
+            name: PROVIDER_NAME,
+            connector: starknetConnector,
+            network: starknetNetwork,
+            disconnectWallets: () => this.disconnectWallets(starknetConnector.id, result?.account),
+            address: result.account,
+            withdrawalSupportedNetworks: this.getSupportedNetworks(),
+            autofillSupportedNetworks: this.getSupportedNetworks(),
+            asSourceSupportedNetworks: this.getSupportedNetworks(),
+        });
+        store.addAccount(starknetConnector.id, result.account);
+        if (resolvedWallet) {
+            store.connectWallet(resolvedWallet);
+            store.setActiveWallet(resolvedWallet.address);
+            return resolvedWallet;
+        }
+        return undefined;
+    }
+    async switchAccount(_wallet, address) {
+        useStarknetStore.getState().setActiveWallet(address);
+    }
+    async hydrateStoredWallets() {
+        const store = useStarknetStore.getState();
+        const starknetAccounts = store.starknetAccounts || {};
+        if (Object.keys(starknetAccounts).length === 0)
+            return;
+        const starknetNetwork = this.getStarknetNetwork();
+        if (!starknetNetwork)
+            return;
+        const connectors = starknetConnectorManager.getConnectors();
+        for (const connector of connectors) {
+            const address = starknetAccounts[connector.id];
+            if (!address || !this.connectorIsAvailable(connector))
+                continue;
+            const wallet = await resolveStarknetWallet({
+                name: PROVIDER_NAME,
+                connector,
+                network: starknetNetwork,
+                disconnectWallets: () => starknetConnectorManager.disconnectAll().then(() => useStarknetStore.getState().removeAccount(address)),
+                withdrawalSupportedNetworks: this.getSupportedNetworks(),
+                autofillSupportedNetworks: this.getSupportedNetworks(),
+                asSourceSupportedNetworks: this.getSupportedNetworks(),
+                address,
+            });
+            if (wallet?.address) {
+                useStarknetStore.getState().connectWallet(wallet);
+            }
+        }
+    }
+    buildProvider() {
+        const { connectedWallets, activeWalletAddress } = useStarknetStore.getState();
+        const activeWallet = connectedWallets.find(wallet => wallet.address === activeWalletAddress);
+        return {
+            connectWallet: this.connectWallet.bind(this),
+            switchAccount: this.switchAccount.bind(this),
+            connectedWallets,
+            activeWallet,
+            withdrawalSupportedNetworks: this.getSupportedNetworks(),
+            autofillSupportedNetworks: this.getSupportedNetworks(),
+            asSourceSupportedNetworks: this.getSupportedNetworks(),
+            availableConnectors: this.getAvailableConnectors(),
+            name: PROVIDER_NAME,
+            id: PROVIDER_ID,
+            providerIcon: this.getProviderIcon(),
+            ready: useStarknetStore.getState().ready,
+        };
+    }
+    getSupportedNetworks() {
+        return this._networkAdapter
+            ? this._networks.filter(network => this._networkAdapter?.isStarknetNetwork(network)).map(network => this._networkAdapter.getId(network))
+            : [];
+    }
+}

package/dist/esm/service/createStarknetConnection.js

@@ -0,0 +1,44 @@
+import { createMemoizedConnectionStore } from "@layerswap/wallet-core";
+import { createStarknetTransfer } from '../transferProvider/createStarknetTransfer';
+import { StarknetConnectionService } from './StarknetConnectionService';
+import { useStarknetStore } from './starknetStore';
+/**
+ * Vanilla external-store factory for the Starknet wallet connection. Replaces the
+ * old `useStarknetConnection` hook.
+ */
+export function createStarknetConnection(initialProps, options = {}) {
+    const { extraMultiStepHandlers = [] } = options;
+    let networks = initialProps.networks;
+    let networkAdapter = initialProps.networkAdapter;
+    const starknetConnectionService = new StarknetConnectionService();
+    starknetConnectionService.setNetworks(networks, networkAdapter);
+    const transferProvider = createStarknetTransfer();
+    const transfer = transferProvider.executeTransfer;
+    return createMemoizedConnectionStore({
+        computeInputs: () => {
+            const state = useStarknetStore.getState();
+            return {
+                connectedWallets: state.connectedWallets,
+                activeWalletAddress: state.activeWalletAddress,
+                connectors: state.connectors,
+                ready: state.ready,
+                networks,
+            };
+        },
+        buildSnapshot: () => ({
+            ...starknetConnectionService.buildProvider(),
+            transfer,
+            multiStepHandlers: extraMultiStepHandlers,
+        }),
+        subscribe: sync => [
+            useStarknetStore.subscribe(sync),
+        ],
+        onUpdateProps: nextProps => {
+            networks = nextProps.networks;
+            networkAdapter = nextProps.networkAdapter;
+            starknetConnectionService.setNetworks(networks, networkAdapter);
+        },
+        // This store owns the module-level Starknet hydration lifecycle.
+        onDestroy: () => starknetConnectionService.dispose(),
+    });
+}

package/dist/esm/service/starknetConnectorManager.js

@@ -0,0 +1,35 @@
+import { useStarknetStore } from './starknetStore';
+class StarknetConnectorManager {
+    constructor() {
+        this._connectors = [];
+    }
+    register(connectors) {
+        this._connectors = connectors;
+        const snapshots = connectors.map(c => ({
+            id: c.id,
+            name: c.name,
+            icon: typeof c.icon === 'string' ? c.icon : (c.icon?.dark || ''),
+        }));
+        useStarknetStore.getState()._setConnectors(snapshots);
+    }
+    getConnectors() {
+        return this._connectors;
+    }
+    getConnector(id) {
+        return this._connectors.find(c => c.id === id);
+    }
+    async disconnectAll() {
+        for (const connector of this._connectors) {
+            try {
+                if (typeof connector.available === 'function' && !connector.available())
+                    continue;
+                await connector.disconnect();
+            }
+            catch { /* swallow */ }
+        }
+    }
+    dispose() {
+        this._connectors = [];
+    }
+}
+export const starknetConnectorManager = new StarknetConnectorManager();