@kheopskit/core 6.0.0-rc.1 → 6.0.0-rc.3

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @kheopskit/core
 
+## 6.0.0-rc.3
+
+### Patch Changes
+
+- [#160](https://github.com/kheopskit/kheopskit/pull/160) [`4e55488`](https://github.com/kheopskit/kheopskit/commit/4e5548833b782669f00e33452f5ed4dff9ddcac0) Thanks [@0xKheops](https://github.com/0xKheops)! - Fixed: a remembered wallet forgotten before it injects is no longer reconnected when it does. A placeholder's `disconnect()` now forgets the wallet, or calls the live wallet's `disconnect()` once that one is discovered. `store.forgetWallet(walletId)` during the session cancels the automatic reconnect for good, even if the wallet is remembered again. `disconnect()` now forgets the wallet whatever its status, including while its automatic reconnect waits for the extension or after that reconnect failed, so the next load does not reconnect it. A wallet the user disconnects during hydration no longer holds `isHydrating` until `hydrationTimeout`.
+
+## 6.0.0-rc.2
+
+### Minor Changes
+
+- [#155](https://github.com/kheopskit/kheopskit/pull/155) [`d3a05e1`](https://github.com/kheopskit/kheopskit/commit/d3a05e14f6eebebf182f3d2ddfee4057321fbab0) Thanks [@0xKheops](https://github.com/0xKheops)! - Added: `account.name` is readable on every account type. Solana accounts take it from the Wallet Standard `label`, and Ethereum accounts leave it `undefined`.
+
+### Patch Changes
+
+- [#157](https://github.com/kheopskit/kheopskit/pull/157) [`2eb5c08`](https://github.com/kheopskit/kheopskit/commit/2eb5c086c201763e84065e05785012d0a845d05d) Thanks [@0xKheops](https://github.com/0xKheops)! - Fixed: Polkadot discovery now reads `window.injectedWeb3` at `load` and 100, 300, 600 and 1100 ms after it, as it already did after subscribe. `isDiscovering` is `true` until the last read, 1100 ms after `load` or after subscribe, whichever is later, so no read is pending once it turns `false`, and that emission lists every extension injected before that read. With `config.walletConnect`, it also waits for the connector to load. A subscription that starts after `load` no longer reads `false` from its first emission. On the server, the registry is read once and no timer is set.
+  
+  Hydration waits for discovery only while a cached wallet has not been discovered. When every cached wallet is discovered and settled, `isHydrating` ends at the grace period without waiting for `load`.
+
 ## 6.0.0-rc.1
 
 ### Patch Changes

package/MIGRATING_TO_V6.md

@@ -48,8 +48,8 @@ This guide grows with each v6 change. Each section covers one area.
 | Test kit | none; apps fake `injectedWeb3` themselves | `@kheopskit/core/testing` | [6](#6-test-kit) |
 | Placeholder SDK handles | typed as present, `undefined` at runtime while hydrating | absent from the placeholder type; narrow on `isPlaceholder` | [7](#7-placeholders-carry-isplaceholder) |
 | `connect()` on a placeholder | throws `PendingWalletError` | waits for the live wallet, or rejects `WALLET_PENDING` | [7](#7-placeholders-carry-isplaceholder) |
-| Hydration end | `isHydrating` stays `true` until every cached connected wallet reconnected, capped at six times the grace period | `isHydrating` ends once the grace period has elapsed, discovery has ended and every wallet that hydrated as `connecting` has settled, or at `hydrationTimeout` (default 3000 ms) | [8](#8-discovery-hydration-end-and-persistence) |
-| Discovery at page load | the Polkadot registry was read at 0, 100, 300, 600 and 1100 ms after subscribe only | read again at `load` and 100 ms later; `state.isDiscovering` says whether that read has landed | [8](#8-discovery-hydration-end-and-persistence) |
+| Hydration end | `isHydrating` stays `true` until every cached connected wallet reconnected, capped at six times the grace period | `isHydrating` ends once the grace period has elapsed and every cached wallet has settled, or at `hydrationTimeout` (default 3000 ms); a cached wallet not yet discovered settles when discovery ends | [8](#8-discovery-hydration-end-and-persistence) |
+| Discovery at page load | the Polkadot registry was read at 0, 100, 300, 600 and 1100 ms after subscribe only | read at subscribe and at `load`, then 100, 300, 600 and 1100 ms after each; `state.isDiscovering` is `true` until the last read, 1100 ms after `load` or after subscribe, whichever is later, and while a WalletConnect connector loads | [8](#8-discovery-hydration-end-and-persistence) |
 | Cache during a slow reconnect | a reconnect slower than the persistence debounce wrote `isConnected: false` and no accounts | a wallet still `connecting` keeps its previous cached entry and accounts | [8](#8-discovery-hydration-end-and-persistence) |
 | React instance and hooks | `createKheopskit` returns a provider and `useWallets`/`useAccounts`; reaching one wallet means reading the whole state; unmounting the provider leaves the pipeline running | `createKheopskit` also returns `kheopskit$` and `store`; `useWallet`, `useAccount` and `useConnect` read one item; unmounting the provider stops the pipeline | [9](#9-kheopskitreact-one-shared-instance-and-wallet-hooks) |
 
@@ -59,10 +59,13 @@ This guide grows with each v6 change. Each section covers one area.
 
 Each section ends with the app code it makes redundant. In short:
 
-- A page-load gate that waits a fixed delay before concluding that a wallet is
-  missing. Wait for `isDiscovering` to turn `false` (section 8).
+- A gate that delays subscribing until `load`, and a fixed grace after it
+  before concluding that a wallet is missing. Both are redundant, because the
+  read window now runs until 1100 ms after `load` or after subscribe,
+  whichever is later. Wait for `isDiscovering` to turn `false` (section 8).
 - Connect dedup wrappers, such as a `requestOnce` or `connectOnce` map keyed by
-  wallet id (section 1).
+  wallet id (section 1). An app that calls `connect()` in reaction to state
+  must then skip a wallet whose `error.code` is `USER_REJECTED`.
 - `auditTime(20)` or `debounceTime(20)` placed after `kheopskit$` to skip the
   stale intermediate state (section 1).
 - Refusal detection by `error.name === "Error"` or by message text. Branch on
@@ -152,7 +155,9 @@ try {
   no caller without one joined, on `disconnect()`, or when the last `kheopskit$`
   subscriber unsubscribes; those reject every remaining caller `ABORTED`.
 - **Resolution follows the state.** `connect()` resolves once `kheopskit$` has
-  emitted a state in which the wallet has `isConnected: true`. `disconnect()`
+  emitted a state in which the wallet has `isConnected: true`. An injected
+  wallet's refused or failed `connect()` rejects after `kheopskit$` has
+  emitted the wallet `disconnected` with that `error`. `disconnect()`
   first waits for the platform's disconnect, when the platform has one, then
   resolves once a state shows `isConnected: false`, or once a later
   `connect()`, the wallet leaving the list or the end of the subscription
@@ -238,7 +243,12 @@ try {
 ### What to delete in your app
 
 - Dedup wrappers around `connect()`, such as a `requestOnce` or `connectOnce`
-  map keyed by wallet id.
+  map keyed by wallet id. Kheopskit shares only concurrent calls. A refused
+  attempt has ended when its `USER_REJECTED` state is emitted, so a
+  `connect()` made in reaction to that state asks the extension again. An app
+  that connects from state skips a wallet whose `error.code` is
+  `USER_REJECTED`. The map used to hide this, because its entry outlived the
+  emission.
 - `auditTime(20)` or `debounceTime(20)` placed after `kheopskit$` to skip the
   stale intermediate state.
 - Treating `WALLET_ALREADY_CONNECTED` as success and swallowing
@@ -264,7 +274,7 @@ try {
 
 The list holds the injected wallets the user connected. Kheopskit adds a
 wallet on every successful connect, whatever `config.autoReconnect` says, and
-removes it when a connected wallet is disconnected. The WalletConnect
+removes it on every `disconnect()`, whatever the wallet's status. The WalletConnect
 connector is never added; AppKit restores its own session. The `autoReconnect`
 config option keeps its name and meaning. It decides whether the remembered
 wallets reconnect on load.
@@ -482,8 +492,8 @@ stays silent. Any other failure sets `wallet.error`, keeps the wallet
 remembered and is retried on the next change to the wallet list, 3 attempts in
 total. A manual `connect()` or `disconnect()` on a remembered wallet ends its
 automatic reconnect for the session. A `disconnect()` while the automatic
-reconnect still waits for the extension aborts it without forgetting the
-wallet, so the next load reconnects it. Automatic reconnect also ends when the
+reconnect still waits for the extension aborts it and forgets the wallet, so
+the next load does not reconnect it. Automatic reconnect also ends when the
 wallet disappears mid-attempt; the wallet stays remembered for the next load.
 Nothing is written to `console.error` any more; `debug: true` logs the failure
 with `console.debug`.
@@ -676,19 +686,19 @@ has no live stream behind it, `connect()` rejects `WALLET_PENDING`.
 
 ### New state field: `isDiscovering`
 
-`KheopskitState.isDiscovering` is new and required. It is `true` until the page
-has fired `load` and kheopskit has read `window.injectedWeb3` again, so the
-emission that turns it `false` already lists every Polkadot extension injected
-by then. It is `false` from the first emission when you subscribe after
-`load`, and always `true` on the server.
+`KheopskitState.isDiscovering` is new and required. It is `true` until the
+last read of `window.injectedWeb3`, 1100 ms after `load` or after subscribe,
+whichever is later, so the emission that turns it `false` already lists every
+Polkadot extension injected before that read. With `config.walletConnect`, it
+also waits for the connector to load. It is always `true` on the server.
 
-Kheopskit now reads the Polkadot registry at `load` and 100 ms after `load`, on
-top of the reads at subscribe and 100, 300, 600 and 1100 ms after it. An
-extension that injects after the 1100 ms read but before `load` is listed
-without a reload. Nothing reads the registry after the last of these reads. A
-wallet that injects after `load` is listed only when a read still runs after
-it, the one 100 ms after `load` or a subscribe read still pending, so its
-discovery is not guaranteed.
+Kheopskit reads the Polkadot registry at subscribe and 100, 300, 600 and
+1100 ms after it, as in 5.x. At `load` it starts the same schedule again, and
+drops the subscribe reads still pending. An extension that injects after the
+1100 ms read but before `load`, or up to 1100 ms after `load`, is listed
+without a reload. A wallet that injects after the last read is not listed
+until the next subscription. On the server kheopskit reads once and sets no
+timer.
 
 A state literal or test mock typed as `KheopskitState` must add the field:
 
@@ -702,8 +712,10 @@ A state literal or test mock typed as `KheopskitState` must add the field:
   };
 ```
 
-Hydration now also waits for discovery. With a cache, `isHydrating` stays
-`true` until `load` or `hydrationTimeout`, whichever comes first. A
+Hydration waits for discovery only while a cached wallet has not been
+discovered. When every cached wallet injects early, `isHydrating` ends at the
+grace period without waiting for `load`. A cached wallet that has not appeared
+holds it until discovery ends or `hydrationTimeout`, whichever comes first. A
 `hydrationGracePeriod` of `0` still turns hydration off in `kheopskit$`. Under
 `KheopskitProvider`, the first render still shows the cached placeholders with
 `isHydrating: true` until the first emission.
@@ -724,14 +736,15 @@ grace period.
 
 ### New end rule
 
-`isHydrating` turns `false` once `hydrationGracePeriod` has elapsed, discovery
-has ended (`isDiscovering` is `false`), and every wallet that hydrated as
-`connecting` has settled. A wallet has settled when it is absent from the
-discovered wallets, connected once its account list has been read (an empty
-list counts) or connected with no cached accounts, disconnected with `error`
-set, or disconnected and not remembered when hydration began. At
-`hydrationTimeout` hydration ends whatever is pending, and a wallet whose
-reconnect is still pending stays `connecting`.
+`isHydrating` turns `false` once `hydrationGracePeriod` has elapsed and every
+cached wallet has settled. A cached wallet missing from the discovered wallets
+settles when discovery ends (`isDiscovering` is `false`). A discovered one
+settles at once unless it hydrated as `connecting`. Then it settles when
+connected once its account list has been read (an empty list counts) or
+connected with no cached accounts, disconnected with `error` set, or
+disconnected and not remembered when hydration began. At `hydrationTimeout`
+hydration ends whatever is pending, and a wallet whose reconnect is still
+pending stays `connecting`.
 
 "Its account list has been read" relies on a signal the built-in plugins send.
 A custom `KheopskitPlatform` plugin, or a wrapper that pipes a built-in
@@ -739,9 +752,8 @@ plugin's `getAccounts$`, does not send it. Such a wallet settles on its first
 listed account, as in 5.x, and a reconnected wallet with cached accounts that
 now lists none holds hydration until `hydrationTimeout`.
 
-- Discovery ends only after the page fires `load`, so a page with a cache
-  hydrates until `load` or `hydrationTimeout`, whichever comes first, even
-  when no wallet reconnects.
+- When every cached wallet is discovered and settled, hydration ends at the
+  grace period, without waiting for `load`.
 - A wallet that reconnects without sharing any account with the site settles
   as soon as it answers; its cached accounts leave the list when hydration
   ends.
@@ -751,15 +763,15 @@ now lists none holds hydration until `hydrationTimeout`.
   may never happen, so waiting
   for it would hold most failed reconnects until `hydrationTimeout`. A retry
   that does run shows on the live wallet's `status`, not as a placeholder.
-- A remembered wallet the user disconnects during or right after its reconnect
-  holds hydration, and shows its cached accounts, until `hydrationTimeout`.
 - A prompt the extension opens for a revoked site holds hydration until the
   user answers or `hydrationTimeout` elapses. After a refusal the wallet is
   forgotten, so the next load opens no prompt.
 
-In practice, with the extension removed or with `autoReconnect: false`,
-hydration no longer runs to 3 s. It ends once the grace period has elapsed and
-the page has loaded, or at `hydrationTimeout` if that comes first.
+In practice, hydration no longer runs to 3 s. With `autoReconnect: false` and
+the extension installed, it ends at the grace period. With the extension
+removed, it ends when discovery ends, 1100 ms after `load` or after subscribe,
+whichever is later (or once a WalletConnect connector has loaded, if later),
+or at `hydrationTimeout` if that comes first.
 
 ### Persistence guarantee
 

package/README.md

@@ -110,6 +110,7 @@ implements them.
 ### Discovery
 
 Source: [`api/polkadot/wallets.ts`](https://github.com/kheopskit/kheopskit/blob/main/packages/core/src/api/polkadot/wallets.ts),
+[`utils/registryReads.ts`](https://github.com/kheopskit/kheopskit/blob/main/packages/core/src/utils/registryReads.ts),
 [`utils/pageLoad.ts`](https://github.com/kheopskit/kheopskit/blob/main/packages/core/src/utils/pageLoad.ts),
 [`api/kheopskit.ts`](https://github.com/kheopskit/kheopskit/blob/main/packages/core/src/api/kheopskit.ts).
 
@@ -117,16 +118,15 @@ Polkadot extensions register themselves on `window.injectedWeb3` and send no
 event, so kheopskit reads that registry on a fixed schedule:
 
 - At subscribe, then 100, 300, 600 and 1100 ms after subscribe.
-- When `window` fires `load`, and again 100 ms after `load`. A subscription
-  that starts after `load` skips these two reads.
+- When `window` fires `load`, then 100, 300, 600 and 1100 ms after `load`. The
+  subscribe reads still pending at `load` are dropped. A subscription that
+  starts after `load` has only the subscribe reads.
 
-Nothing reads the registry after the last of these reads. A wallet that
-injects after `load` is listed only when a read still runs after it, the one
-100 ms after `load` or a subscribe read still pending, so its discovery is not
-guaranteed. Wallets inject `injectedWeb3` while the page loads, so a wallet
-that injects after the last read is not listed until the next subscription,
-usually the next page load. Kheopskit has no
-`refreshWallets()` and does not read again on focus or on connect.
+The read window ends 1100 ms after `load` or after subscribe, whichever is
+later. Nothing reads the registry after that, so a wallet that injects later
+is not listed until the next subscription, usually the next page load.
+Kheopskit has no `refreshWallets()` and does not read again on focus or on
+connect. On the server it reads once and sets no timer.
 
 Ethereum (EIP-6963, through `mipd`) and Solana (Wallet Standard) wallets
 announce themselves with events, so those lists update whenever a wallet
@@ -134,19 +134,19 @@ announces or unregisters.
 
 `state.isDiscovering` tells you whether the list may still grow:
 
-- `true` when the subscription started before `document.readyState` was
-  `"complete"`.
-- It turns `false` in the first emission after `load` in which the registry was
-  read again. That emission already lists every extension injected by `load`.
-  Wait for it before you conclude that a wallet is missing.
-- `false` from the first emission when you subscribe after `load`.
+- `true` until the read window ends, 1100 ms after `load` or after subscribe,
+  whichever is later, and while a WalletConnect connector loads.
+- It turns `false` in the emission of the last read, or once the
+  WalletConnect connector has loaded if that comes later. That emission lists
+  every Polkadot extension injected before the last read. Wait for it before
+  you conclude that a wallet is missing.
 - Always `true` on the server.
 
-It says nothing about wallets that inject after `load`. In the end-to-end test
-`e2e/tests/discovery-at-load.spec.ts`, an extension injected 1500 ms after the
-first read and before `load` showed in the wallet list 16.2 ms after `load` on
-vite-react, and 15.8 to 18.3 ms across the three example apps (the test's
-limit is 300 ms).
+In the end-to-end test `e2e/tests/discovery-at-load.spec.ts`, an extension
+injected 1500 ms after the first read and before `load` showed in the wallet
+list 23.9 ms after `load` on vite-react, and 13.1 to 23.9 ms across the three
+example apps (the test's limit is 300 ms). The "Looking for wallets…" status
+went away 1114 to 1124 ms after `load`.
 
 ### Hydration
 
@@ -180,7 +180,9 @@ A placeholder wallet is never connected. Its `connect()` waits for kheopskit to
 discover the live wallet with the same id and connects that one. It rejects
 with `WALLET_PENDING` if hydration ends first, and with `ABORTED` if its
 `signal` fires or the last subscriber unsubscribes while it waits. Its
-`disconnect()` resolves at once. A cached wallet that kheopskit has already
+`disconnect()` forgets the wallet and resolves at once, so kheopskit does not
+reconnect it when it injects. Once the live wallet is discovered, it calls the
+live wallet's `disconnect()` instead. A cached wallet that kheopskit has already
 discovered is no longer a placeholder. It carries its live `connect()` and
 `disconnect()` and shows `status: "connecting"` while its reconnect runs, and
 its `connect()` joins that reconnect. A Polkadot wallet's `extension` stays
@@ -190,13 +192,15 @@ its `connect()` joins that reconnect. A Polkadot wallet's `extension` stays
 `isHydrating` turns `false` once all three hold:
 
 1. `hydrationGracePeriod` has elapsed (default 500 ms).
-2. Discovery has ended (`isDiscovering` is `false`), so a page with a cache
-   hydrates until `load` or `hydrationTimeout`, whichever comes first.
-3. Every wallet that hydrated as `connecting` has settled. A wallet has
-   settled when it is absent from the discovered wallets, connected once its
-   account list has been read (an empty list counts) or connected with no
-   cached accounts, disconnected with `error` set, or disconnected and not
-   remembered when hydration began.
+2. Every cached wallet has been discovered, or discovery has ended
+   (`isDiscovering` is `false`). When every cached wallet injects early,
+   hydration does not wait for `load`. A cached wallet that has not appeared
+   holds it until discovery ends.
+3. Every discovered wallet that hydrated as `connecting` has settled. It has
+   settled when connected once its account list has been read (an empty list
+   counts) or connected with no cached accounts, disconnected with `error`
+   set, or disconnected and not remembered. A wallet remembered after
+   hydration began does not count.
 
 At `hydrationTimeout` (default 3000 ms) hydration ends whatever is pending, and
 a wallet whose reconnect is still pending stays `connecting`. The timeout wins
@@ -208,8 +212,6 @@ over a longer grace period, so an app that raises `hydrationGracePeriod` sets
   ends.
 - A failed reconnect ends that wallet's wait, even when the reconnect policy
   still permits a retry.
-- A remembered wallet the user disconnects during or right after its reconnect
-  holds hydration, and shows its cached accounts, until `hydrationTimeout`.
 - A prompt the extension opens for a revoked site holds hydration until the
   user answers or `hydrationTimeout` elapses.
 - "Its account list has been read" relies on a signal that the built-in
@@ -240,8 +242,8 @@ Source: [`api/wallets.ts`](https://github.com/kheopskit/kheopskit/blob/main/pack
 [`api/injectedWallets.ts`](https://github.com/kheopskit/kheopskit/blob/main/packages/core/src/api/injectedWallets.ts).
 
 Kheopskit adds an injected wallet to the store's `remembered` list on every
-successful `connect()` and removes it when `disconnect()` starts on a
-connected wallet, whatever `autoReconnect` says, so an app can turn reconnect
+successful `connect()` and removes it when `disconnect()` starts, whatever the
+wallet's status and whatever `autoReconnect` says, so an app can turn reconnect
 on later. On the next load it reconnects the remembered injected wallets that
 `autoReconnect` accepts:
 
@@ -276,7 +278,13 @@ or removed, or any wallet's status changing), 3 attempts in total. If the list
 never changes again, no retry runs. A manual `connect()` or `disconnect()` on a
 remembered wallet ends its automatic reconnect for the session. A
 `disconnect()` while the automatic reconnect still waits for the extension
-aborts it without forgetting the wallet, so the next load reconnects it.
+aborts it and forgets the wallet, so the next load does not reconnect it.
+Forgetting a wallet with `store.forgetWallet(walletId)`, or calling
+`disconnect()` on its placeholder before it injects, ends its automatic
+reconnect for the rest of the session, even if the wallet is remembered again.
+The next load reconnects it only if it is remembered by then.
+`store.forgetWallet(walletId)` does not stop an attempt that already
+waits for the extension. The wallet's `disconnect()` does.
 Automatic reconnect also ends when the wallet disappears mid-attempt, and the
 wallet stays remembered for the next load.
 
@@ -401,6 +409,13 @@ the order the extension lists them in. `state.wallets` follows the same
 platform order, then the WalletConnect connector, with Talisman first, then by
 name.
 
+Every account has an optional `name`. On Polkadot it is the account name the
+extension lists. On Solana it is the Wallet Standard `label`, when the wallet
+provides one. On Ethereum it is always `undefined`, because EIP-1193 and
+EIP-6963 expose no account name. A wallet can report an empty name, so
+`account.name || account.address` gives a display label on every platform. A
+cached placeholder keeps the `name` of the account it stands for.
+
 ### Persistence
 
 Source: [`api/store.ts`](https://github.com/kheopskit/kheopskit/blob/main/packages/core/src/api/store.ts),
@@ -424,9 +439,8 @@ goes to `localStorage` as JSON:
 ```
 
 - `remembered` lists the injected wallets the user connected. It is written as
-  soon as a connect succeeds and cleared as soon as `disconnect()` starts on a
-  connected wallet. A `disconnect()` that aborts a pending connect leaves it
-  unchanged.
+  soon as a connect succeeds and cleared as soon as `disconnect()` starts,
+  whatever the wallet's status.
 - `cachedWallets` and `cachedAccounts` are written by the hydration rule above:
   after hydration ends, 1 second after the state stops changing.
 - Wallet icons go to a separate `localStorage` key, `kheopskit-icons`, to keep
@@ -666,17 +680,22 @@ fail.
 
 ### Design choices
 
-- Kheopskit does not look for wallets that inject after `load`, and has no
-  `refreshWallets()`. Wallets inject at page load, and a rescan would add
-  timers and states for a case no supported wallet produces.
+- Kheopskit stops reading the Polkadot registry when the read window ends, and
+  has no `refreshWallets()`. Wallets inject at page load, and a permanent
+  watcher would add timers and states for a case no supported wallet produces.
 - No `walletsReady` promise. It would be a second surface for the one fact
   `isDiscovering` carries.
-- No longer fixed poll. Any duration is still a guess about how long a page
-  takes to boot, and wallets inject before `load`.
-- Discovery does not end at the last scheduled read (1100 ms). On a warm load
-  that is slower than `load`, for no gain.
-- `remembered` is read once at subscribe. A live read would make a connect in
-  one tab connect every open tab, with no matching disconnect.
+- The read window restarts at `load` instead of running a longer poll from
+  subscribe. Its coverage after `load` then no longer depends on when the app
+  subscribes.
+- Discovery ends with the last read, 1100 ms after `load` (or once a
+  WalletConnect connector has loaded, if later), not at `load`, so a wallet
+  that injects shortly after `load` is listed before `isDiscovering` turns
+  `false`.
+  Hydration waits for that end only while a cached wallet is missing.
+- A wallet remembered after subscribe is not reconnected. Reconnecting it
+  would make a connect in one tab connect every open tab, with no matching
+  disconnect. A wallet forgotten after subscribe is not reconnected either.
 - No `persist: false` option. The `autoReconnect` predicate covers "do not
   reconnect", and `storageKey` keeps two dapps apart.
 

package/dist/ethereum.d.mts

@@ -1,4 +1,4 @@
-import { E as isWalletConnectWallet, N as WalletAccountId, T as isInjectedWallet, b as WalletConnectWallet, k as WalletId, l as KheopskitPlatform, m as PlaceholderWallet, p as Placeholder, r as BaseWallet } from "./types-lkMXVJNG.mjs";
+import { E as isWalletConnectWallet, N as WalletAccountId, T as isInjectedWallet, b as WalletConnectWallet, k as WalletId, l as KheopskitPlatform, m as PlaceholderWallet, p as Placeholder, r as BaseWallet } from "./types-C3I3w0jb.mjs";
 import { Account, CustomTransport, EIP1193Provider, WalletClient } from "viem";
 //#region src/utils/isEthereumAddress.d.ts
 /**
@@ -47,6 +47,7 @@ type LiveEthereumAccount = {
   address: `0x${string}`;
   /** Current chain ID the wallet is connected to. `undefined` while loading or after provider disconnect. */
   chainId: number | undefined;
+  name?: string;
   walletName: string;
   walletId: WalletId;
 };

package/dist/ethereum.d.ts

@@ -1,4 +1,4 @@
-import { E as isWalletConnectWallet, N as WalletAccountId, T as isInjectedWallet, b as WalletConnectWallet, k as WalletId, l as KheopskitPlatform, m as PlaceholderWallet, p as Placeholder, r as BaseWallet } from "./types-lkMXVJNG.js";
+import { E as isWalletConnectWallet, N as WalletAccountId, T as isInjectedWallet, b as WalletConnectWallet, k as WalletId, l as KheopskitPlatform, m as PlaceholderWallet, p as Placeholder, r as BaseWallet } from "./types-C3I3w0jb.js";
 import { Account, CustomTransport, EIP1193Provider, WalletClient } from "viem";
 //#region src/utils/isEthereumAddress.d.ts
 /**
@@ -47,6 +47,7 @@ type LiveEthereumAccount = {
   address: `0x${string}`;
   /** Current chain ID the wallet is connected to. `undefined` while loading or after provider disconnect. */
   chainId: number | undefined;
+  name?: string;
   walletName: string;
   walletId: WalletId;
 };

package/dist/ethereum.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_types = require("./types-BWHvNFlN.js");
 const require_platformAccounts = require("./platformAccounts-BjIeRcFN.js");
-const require_injectedWallets = require("./injectedWallets-Dy8YGKL-.js");
+const require_injectedWallets = require("./injectedWallets-BQBgS-f0.js");
 let rxjs = require("rxjs");
 let viem = require("viem");
 let mipd = require("mipd");

package/dist/ethereum.mjs

@@ -1,6 +1,6 @@
 import { _ as getCachedObservable$, a as isEip1193UserRejection, h as clearCachedObservable, n as isWalletConnectWallet, t as isInjectedWallet, u as getWalletId } from "./types-Yor672md.mjs";
 import { d as isEthereumAddress, i as getSessionCaip10s, o as getWalletAccountId, r as getCaip10Addresses, t as createPlatformAccounts$ } from "./platformAccounts-yyRUrnel.mjs";
-import { t as createInjectedWallets$ } from "./injectedWallets-48L-AL1I.mjs";
+import { t as createInjectedWallets$ } from "./injectedWallets-5GL1Jder.mjs";
 import { Observable, ReplaySubject, combineLatest, distinctUntilChanged, map, of, shareReplay } from "rxjs";
 import { createWalletClient, custom, getAddress } from "viem";
 import { createStore } from "mipd";

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { t as SyncableStorage } from "./storage-D3AwNgqc.mjs";
-import { A as getWalletId, C as WalletStatus, D as KheopskitError, E as isWalletConnectWallet, F as parseWalletAccountId, M as parseWalletId, N as WalletAccountId, O as KheopskitErrorCode, P as getWalletAccountId, S as WalletPlatform, T as isInjectedWallet, _ as WalletConnectMetadata, a as CachedAccount, b as WalletConnectWallet, c as KheopskitConfig, d as KheopskitStore, f as KheopskitStoreData, g as PolkadotAccountType, h as PlatformContext, i as BaseWalletAccount, j as isValidWalletId, k as WalletId, l as KheopskitPlatform, m as PlaceholderWallet, n as AppKitInstance, o as CachedWallet, p as Placeholder, r as BaseWallet, s as ConnectOptions, t as AccountOf, u as KheopskitState, v as WalletConnectPlugin, w as WalletType, x as WalletOf, y as WalletConnectProvider } from "./types-lkMXVJNG.mjs";
+import { A as getWalletId, C as WalletStatus, D as KheopskitError, E as isWalletConnectWallet, F as parseWalletAccountId, M as parseWalletId, N as WalletAccountId, O as KheopskitErrorCode, P as getWalletAccountId, S as WalletPlatform, T as isInjectedWallet, _ as WalletConnectMetadata, a as CachedAccount, b as WalletConnectWallet, c as KheopskitConfig, d as KheopskitStore, f as KheopskitStoreData, g as PolkadotAccountType, h as PlatformContext, i as BaseWalletAccount, j as isValidWalletId, k as WalletId, l as KheopskitPlatform, m as PlaceholderWallet, n as AppKitInstance, o as CachedWallet, p as Placeholder, r as BaseWallet, s as ConnectOptions, t as AccountOf, u as KheopskitState, v as WalletConnectPlugin, w as WalletType, x as WalletOf, y as WalletConnectProvider } from "./types-C3I3w0jb.mjs";
 import { t as clearAllCachedObservables } from "./getCachedObservable-LUq9IfEx.mjs";
 import { Observable } from "rxjs";
 //#region src/utils/isValidAddress.d.ts

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as SyncableStorage } from "./storage-D3AwNgqc.js";
-import { A as getWalletId, C as WalletStatus, D as KheopskitError, E as isWalletConnectWallet, F as parseWalletAccountId, M as parseWalletId, N as WalletAccountId, O as KheopskitErrorCode, P as getWalletAccountId, S as WalletPlatform, T as isInjectedWallet, _ as WalletConnectMetadata, a as CachedAccount, b as WalletConnectWallet, c as KheopskitConfig, d as KheopskitStore, f as KheopskitStoreData, g as PolkadotAccountType, h as PlatformContext, i as BaseWalletAccount, j as isValidWalletId, k as WalletId, l as KheopskitPlatform, m as PlaceholderWallet, n as AppKitInstance, o as CachedWallet, p as Placeholder, r as BaseWallet, s as ConnectOptions, t as AccountOf, u as KheopskitState, v as WalletConnectPlugin, w as WalletType, x as WalletOf, y as WalletConnectProvider } from "./types-lkMXVJNG.js";
+import { A as getWalletId, C as WalletStatus, D as KheopskitError, E as isWalletConnectWallet, F as parseWalletAccountId, M as parseWalletId, N as WalletAccountId, O as KheopskitErrorCode, P as getWalletAccountId, S as WalletPlatform, T as isInjectedWallet, _ as WalletConnectMetadata, a as CachedAccount, b as WalletConnectWallet, c as KheopskitConfig, d as KheopskitStore, f as KheopskitStoreData, g as PolkadotAccountType, h as PlatformContext, i as BaseWalletAccount, j as isValidWalletId, k as WalletId, l as KheopskitPlatform, m as PlaceholderWallet, n as AppKitInstance, o as CachedWallet, p as Placeholder, r as BaseWallet, s as ConnectOptions, t as AccountOf, u as KheopskitState, v as WalletConnectPlugin, w as WalletType, x as WalletOf, y as WalletConnectProvider } from "./types-C3I3w0jb.js";
 import { t as clearAllCachedObservables } from "./getCachedObservable-LUq9IfEx.js";
 import { Observable } from "rxjs";
 //#region src/utils/isValidAddress.d.ts

package/dist/index.js

@@ -2,9 +2,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_types = require("./types-BWHvNFlN.js");
 const require_platformAccounts = require("./platformAccounts-BjIeRcFN.js");
 const require_iconCache = require("./iconCache-FR4iy6go.js");
-const require_pageLoad = require("./pageLoad-D1wLeuFG.js");
-let rxjs = require("rxjs");
+const require_registryReads = require("./registryReads-BpHsWLd7.js");
 let lodash_es = require("lodash-es");
+let rxjs = require("rxjs");
 //#region src/api/config.ts
 /**
 * Default storage key for persisting wallet connection state.
@@ -107,6 +107,10 @@ const createReconnectPolicy = ({ maxAttempts = 3 } = {}) => {
 	};
 };
 const reconnectAccepts = (autoReconnect, wallet) => typeof autoReconnect === "function" ? autoReconnect(wallet) : autoReconnect;
+const reconnectCandidates$ = (store) => {
+	const remembered$ = store.observable.pipe((0, rxjs.map)((s) => s.remembered ?? []));
+	return remembered$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)((initial) => remembered$.pipe((0, rxjs.scan)((remaining, current) => remaining.filter((id) => current.includes(id)), initial))), (0, rxjs.distinctUntilChanged)(lodash_es.isEqual));
+};
 //#endregion
 //#region src/api/hydration.ts
 /**
@@ -557,15 +561,12 @@ const getDefaultStore = () => {
 };
 //#endregion
 //#region src/api/wallets.ts
-const getWallets$ = (config, store) => {
-	const rememberedWalletIds$ = store.observable.pipe((0, rxjs.map)((s) => s.remembered ?? []), (0, rxjs.take)(1), (0, rxjs.shareReplay)({
-		bufferSize: 1,
-		refCount: true
-	}));
+const getWallets$ = (config, store, registryReads$) => {
 	return new rxjs.Observable((subscriber) => {
 		const ctx = {
 			config,
-			store
+			store,
+			registryReads$
 		};
 		const observables = config.platforms.map((plugin) => plugin.getWallets$(ctx));
 		const reconnectPolicy = createReconnectPolicy();
@@ -598,7 +599,7 @@ const getWallets$ = (config, store) => {
 		};
 		const subWallets = wallets$.subscribe(subscriber);
 		if (subscriber.closed) return subWallets;
-		const subAutoReconnect = (0, rxjs.combineLatest)([rawWallets$, rememberedWalletIds$]).pipe((0, rxjs.filter)(([, walletIds]) => config.autoReconnect !== false && walletIds.length > 0), (0, rxjs.mergeMap)(([wallets, walletIds]) => wallets.filter(require_types.isInjectedWallet).filter((wallet) => walletIds.includes(wallet.id))), (0, rxjs.tap)((wallet) => {
+		const subAutoReconnect = rawWallets$.pipe((0, rxjs.withLatestFrom)(reconnectCandidates$(store)), (0, rxjs.filter)(([, walletIds]) => config.autoReconnect !== false && walletIds.length > 0), (0, rxjs.mergeMap)(([wallets, walletIds]) => wallets.filter(require_types.isInjectedWallet).filter((wallet) => walletIds.includes(wallet.id))), (0, rxjs.tap)((wallet) => {
 			if (wallet.status === "connected") reconnectPolicy.settle(wallet.id);
 		}), (0, rxjs.filter)((wallet) => wallet.status === "disconnected" && reconnectAccepts(config.autoReconnect, wallet))).subscribe(reconnect);
 		return () => {
@@ -682,6 +683,12 @@ const getKheopskit$ = (config, options = {}) => {
 				const live = await whenLive(placeholder.id, options?.signal);
 				if (closed) throw require_types.abortedError(placeholder.id, "connect");
 				await live.connect(options);
+			},
+			disconnect: async () => {
+				if (closed) return;
+				const live = latest?.wallets.find((w) => w.id === placeholder.id && !w.isPlaceholder);
+				if (live) return live.disconnect();
+				store.forgetWallet(placeholder.id);
 			}
 		});
 		const settleWithState = (wallet) => {
@@ -711,26 +718,32 @@ const getKheopskit$ = (config, options = {}) => {
 			wrapped.set(wallet, settled);
 			return settled;
 		};
-		const liveWallets$ = getWallets$(kc, store);
+		const registryReads$ = require_registryReads.createRegistryReads$().pipe((0, rxjs.shareReplay)({
+			bufferSize: 1,
+			refCount: true
+		}));
+		const liveWallets$ = getWallets$(kc, store, registryReads$);
 		const accountFrames$ = getAccounts$(kc, liveWallets$);
 		const liveAccounts$ = accountFrames$.pipe((0, rxjs.map)(({ accounts }) => accounts.map(asLive)));
-		const isDiscovering$ = require_pageLoad.pageLoaded$.pipe((0, rxjs.switchMap)((loaded) => loaded ? liveWallets$.pipe((0, rxjs.take)(1), (0, rxjs.map)(() => false)) : (0, rxjs.of)(true)), (0, rxjs.shareReplay)({
+		const isDiscovering$ = (0, rxjs.concat)((0, rxjs.of)(true), registryReads$.pipe((0, rxjs.ignoreElements)()), liveWallets$.pipe((0, rxjs.take)(1), (0, rxjs.map)(() => false))).pipe((0, rxjs.shareReplay)({
 			bufferSize: 1,
 			refCount: true
 		}));
-		const reconnecting = cachedWallets.filter((w) => w.status === "connecting");
 		const hydrationSettled$ = (0, rxjs.combineLatest)([
 			liveWallets$,
 			accountFrames$.pipe((0, rxjs.startWith)(noAnswerYet)),
 			isDiscovering$,
-			store.observable.pipe((0, rxjs.map)((s) => s.remembered ?? []), (0, rxjs.take)(1))
-		]).pipe((0, rxjs.map)(([wallets, { accounts, answered }, isDiscovering, remembered]) => !isDiscovering && reconnecting.every((cached) => reconnectSettled(cached, {
-			wallets,
-			accounts,
-			answered,
-			cachedAccounts,
-			remembered
-		}))), (0, rxjs.debounceTime)(0, rxjs.asapScheduler), (0, rxjs.distinctUntilChanged)());
+			reconnectCandidates$(store)
+		]).pipe((0, rxjs.map)(([wallets, { accounts, answered }, isDiscovering, remembered]) => cachedWallets.every((cached) => {
+			const wallet = wallets.find((w) => w.id === cached.id);
+			if (!wallet) return !isDiscovering;
+			return cached.status !== "connecting" || reconnectSettled(cached, wallet, {
+				accounts,
+				answered,
+				cachedAccounts,
+				remembered
+			});
+		})), (0, rxjs.debounceTime)(0, rxjs.asapScheduler), (0, rxjs.distinctUntilChanged)());
 		const bufferedWallets$ = createHydrationBuffer(cachedWallets, liveWallets$.pipe((0, rxjs.map)((wallets) => wallets.map(asLive))), kc.hydrationGracePeriod, kc.hydrationTimeout, (w) => w.id, hydrationSettled$, (live, cached) => {
 			const status = sessionRestoring(live, cached) ? "connecting" : live.status;
 			return {
@@ -832,9 +845,7 @@ const noAnswerYet = {
 * waiting for its reconnect: getWallets$ emits the wallet list before its
 * connect() flips the status to connecting.
 */
-const reconnectSettled = (cached, live) => {
-	const wallet = live.wallets.find((w) => w.id === cached.id);
-	if (!wallet) return true;
+const reconnectSettled = (cached, wallet, live) => {
 	const status = sessionRestoring(wallet, cached) ? "connecting" : wallet.status;
 	if (status === "connecting") return false;
 	if (status === "disconnected") return wallet.error !== void 0 || !live.remembered.includes(cached.id);