@multiplatform.one/web3 7.23.2 → 7.25.0

package/README.md

@@ -22,8 +22,10 @@ Peers: `react`, `@tanstack/react-query`.
   `useBalance`, `useConnect`, `useSignMessage`, `useSwitchChain`, …)
 - **Components** — `ConnectKitButton`, `WalletButton`, `WalletAvatar`,
   `WalletStatus`, `NetworkSwitcher`
-- **Subpaths** — `./native` (WebView wallet bridge), `./connectkit`, `./vite`
-  and `./esbuild` (bundler plugins, below)
+- **Subpaths** — `./native` (WebView wallet bridge), `./connectkit`,
+  `./message` (the wallet sign-in messages), `./keycloak` (wallet login
+  against the Keycloak wallet SPI), `./vite` and `./esbuild` (bundler
+  plugins, below)
 
 ## Per-chain clients
 
@@ -34,12 +36,12 @@ or a provider's `request`. Every client shares
 verifiers take: EVM 0x hex, Solana base58, Sui base64, Bitcoin base64 BIP-322,
 GPG the armored signature plus the armored public key.
 
-| Hook / factory                                                                    | What it adds                                                                                                                                                                                                                                                                |
-| --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `useEvmClient()` / `evmClient({ walletClient } \| { provider, account, chain })`  | viem `walletClient` + `publicClient`, `sendTransaction`, `writeContract`, `waitForTransactionReceipt`, `erc20.{transfer, approve, ensureAllowance, balanceOf, allowance, decimals}`, safe for tokens like USDT that return nothing or refuse a non-zero to non-zero approve |
-| `useSolanaClient()` / `solanaClient({ signer, rpcUrl?, chain? })` from `./solana` | web only: `@solana/kit` `rpc`, `signTransaction`, `signAndSendTransaction`, `sendTransaction`, `confirmTransaction`, `getBalance`, `transferSol`                                                                                                                            |
-| `useGpgSigner()` / `createGpgSigner()`                                            | the copy/paste GPG signer: `signMessage` parks a request with its terminal `command`; `submit(pasted, request)` resolves it only while `request` is still the pending one and the pasted signature covers its message                                                       |
-| `useSuiClient()`, `useBitcoinClient()`                                            | message signing only; `signTransaction` / `signPsbt` reject with `UnsupportedClientMethodError` until transactions land                                                                                                                                                     |
+| Hook / factory                                                                    | What it adds                                                                                                                                                                                                                                                                                                       |
+| --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `useEvmClient()` / `evmClient({ walletClient } \| { provider, account, chain })`  | viem `walletClient` + `publicClient`, `sendTransaction`, `writeContract`, `waitForTransactionReceipt`, `confirmTransaction`, `explorerTxUrl`, `erc20.{transfer, approve, ensureAllowance, balanceOf, allowance, decimals}`, safe for tokens like USDT that return nothing or refuse a non-zero to non-zero approve |
+| `useSolanaClient()` / `solanaClient({ signer, rpcUrl?, chain? })` from `./solana` | web only: `@solana/kit` `rpc`, `signTransaction`, `signAndSendTransaction`, `sendTransaction`, `confirmTransaction`, `getBalance`, `transferSol`                                                                                                                                                                   |
+| `useGpgSigner()` / `createGpgSigner()`                                            | the copy/paste GPG signer: `signMessage` parks a request with its terminal `command`; `submit(pasted, request)` resolves it only while `request` is still the pending one and the pasted signature covers its message                                                                                              |
+| `useSuiClient()`, `useBitcoinClient()`                                            | message signing only; `signTransaction` / `signPsbt` reject with `UnsupportedClientMethodError` until transactions land                                                                                                                                                                                            |
 
 ```tsx
 import { useEvmClient } from "@multiplatform.one/web3";
@@ -56,9 +58,13 @@ await sol?.confirmTransaction(sent!);
 
 `transferSol` returns the signature with the blockhash's `lastValidBlockHeight`,
 and `confirmTransaction` waits until the chain passes that height before it
-gives up. Its `SolanaConfirmationError` has `mayStillLand`: `false` means the
-transaction failed or expired and a retry is safe; `true` (only when there was
-no `lastValidBlockHeight` to judge by) means resending can pay twice.
+gives up. Its `SolanaConfirmationError` has a `reason` and `mayStillLand`.
+`failed` and `expired` set it `false`: the transaction will not land and a retry
+is safe. `timeout` (there was no `lastValidBlockHeight` to judge by) and `rpc`
+(a `getSignatureStatuses` or `getBlockHeight` poll failed, with the transport
+error as `cause`) set it `true`: resending can pay twice, so call
+`confirmTransaction` again on the same submission instead. `lastStatus` is the
+last `confirmationStatus` the poll saw, `null` when it never saw the signature.
 
 A Solana client runs over a byte-level `SolanaSigner`: `standardSolanaSigner`
 (Wallet Standard: Phantom, Solflare, Backpack), `injectedSolanaSigner` (what the
@@ -72,6 +78,107 @@ signs Solana through the WebView bridge, so the root never imports
 through `solanaMessageClient`, so a login page carries no kit.
 `tests/clients/importGraph.spec.ts` holds both lines, for native and web.
 
+### EVM payments: pending is not failed
+
+A sent transaction can sit in the mempool for minutes and still land. viem's
+receipt wait gives up after 180 s with an error that reads like a failure, so
+an app would offer "try again" and the user would pay twice. The EVM client
+never does that:
+
+- `waitForTransactionReceipt(hash)` and `confirmTransaction(hash)` wait with
+  no timeout. Pass `{ timeout }` for a deadline, which holds even while an
+  RPC call hangs. Running out rejects with
+  `ReceiptPendingError` (`hash`, `chainId`, `explorerUrl`, `nonce` once the
+  node has seen it, `mayStillLand: true`), never a generic error. A failing
+  RPC never ends the wait: it backs off, up to 30 s between polls, and
+  retries.
+- Pass `{ signal }` and abort it when the screen unmounts. A wait with no
+  timeout otherwise polls until the transaction settles, which for a dropped
+  one is forever. It rejects with `ReceiptWaitAbortedError`, an `AbortError`.
+- `confirmTransaction` also rejects a reverted receipt with
+  `TransactionRevertedError`. `waitForTransactionReceipt` still resolves it,
+  as it always has.
+- When another transaction takes the nonce, both reject with
+  `TransactionReplacedError`: `reason` is `cancelled` (the wallet's cancel),
+  `replaced` (a different transaction), or `unmatched` (the original was never
+  seen, so it could be a speed-up). A speed-up resolves with the faster copy's
+  receipt. The wait binary-searches the nonce's block however long it slept,
+  so resuming one far back needs an RPC that serves state that old, an
+  archive node. A chain's default public RPC often keeps only the last 128
+  blocks, and past that the wait stays pending.
+- `erc20.ensureAllowance` confirms its approvals the same way and takes the
+  same `timeout` and `signal`. `erc20.transfer` and `approve` return once the wallet sends,
+  and their rejections classify too.
+
+`classifyTxError(error)` sorts any of these, and viem's own errors, into what
+to show:
+
+| Kind            | Meaning                                                               | Show                                           |
+| --------------- | --------------------------------------------------------------------- | ---------------------------------------------- |
+| `user-rejected` | declined or cancelled in the wallet; nothing paid                     | "Cancelled", buy enabled                       |
+| `reverted`      | the contract refused it, in simulation or on chain; nothing paid      | the reason, buy enabled                        |
+| `pending`       | sent with no receipt yet, or its nonce went to what may be a speed-up | "Pending" with the explorer link, buy disabled |
+| `aborted`       | the app stopped waiting; the transaction is as pending as it was      | nothing; keep the pending hash                 |
+| `failed`        | anything else: no hash came back, or a different transaction won      | the error, buy enabled                         |
+
+`failed` with no hash usually means nothing was sent. A wallet that errors
+after the user approved may still have broadcast it, so tell the user to
+check the wallet's activity before paying again.
+
+Persist the hash from the moment the wallet returns it, and what `onTrack`
+hands over: the nonce once the node has seen the transaction, and a speed-up's
+hash when one replaces it. A wait resumed after a reload needs the nonce to
+notice a cancel or replacement that landed while the app was closed; without
+it, a transaction the node has forgotten stays pending. A speed-up the page
+never saw can't be told from a replacement after a reload, so it stays
+pending too. Refuse a second buy while one is pending:
+
+```tsx
+import { classifyTxError, useEvmClient } from "@multiplatform.one/web3";
+
+const evm = useEvmClient();
+const [pending, setPending] = usePersistedState<{ hash: Hash; nonce?: number } | null>("buy", null);
+
+async function settle(hash: Hash, nonce: number | undefined, signal: AbortSignal) {
+  try {
+    await evm.confirmTransaction(hash, { nonce, signal, onTrack: setPending });
+    setPending(null);
+    showPaid();
+  } catch (error) {
+    const kind = classifyTxError(error);
+    // aborted: unmounted, and the next mount resumes it. pending: superseded,
+    // maybe sped up, so keep it locked.
+    if (kind === "aborted" || kind === "pending") return;
+    setPending(null);
+    showFailure(kind, error);
+  }
+}
+
+// Every wait belongs to a mounted screen, and stops when it unmounts.
+useEffect(() => {
+  if (!evm || !pending) return;
+  const controller = new AbortController();
+  void settle(pending.hash, pending.nonce, controller.signal);
+  return () => controller.abort();
+}, [evm, pending?.hash]);
+
+async function buy() {
+  if (!evm || pending) return;
+  try {
+    await evm.erc20.ensureAllowance({ token: qcc, spender: store, amount });
+    const hash = await evm.writeContract({ address: store, abi, functionName: "buy", args: [id] });
+    setPending({ hash });
+  } catch (error) {
+    showFailure(classifyTxError(error), error);
+  }
+}
+```
+
+While `pending` is set, disable buy and link `evm.explorerTxUrl(pending.hash)`.
+The effect settles it on mount and after a reload; a "check again" button can
+remount it. When the client can't settle it, your backend, which sees the
+purchase land, is the one to release the lock.
+
 ### Solana on mobile (follow-up)
 
 The web path is done. A native app cannot reach Phantom through the WebView
@@ -136,6 +243,39 @@ React Native builds don't need it: the native `WalletProvider` renders the
 wallet UI from `assets/webview.html`, which this package builds with the
 plugin.
 
+## Native apps: the WebView bridge
+
+A native app does not link wallet SDKs. The native `WalletProvider` (the
+`./native` entry) loads the wallet UI, `assets/webview.html`, in a WebView and
+talks to it over a JSON bridge: `evm` (EIP-1193), `solana`, `sui` and `gpg`
+signing, and `auth`, the Keycloak wallet sign-in. Everything runs on
+`react-native-webview` and `Linking`, so stock Expo Go runs it.
+
+Serve `webview.html` over https and set `webViewUrl` to it. The page's host
+is the sign-in message's domain and the host the Keycloak nonce cookie is set
+for, so it must be in the realm's `siww.allowedDomains` (SHC Keycloak) or
+`wallet.allowedDomains` (mpo Keycloak), and its origin in the client's web
+origins. The provider refuses any other URL; plain http is accepted only on
+`localhost`, `127.0.0.1`, `[::1]` and `10.0.2.2`, in development builds.
+
+```tsx
+import { useWalletBridge } from "@multiplatform.one/web3";
+
+const { auth, sui, gpg } = useWalletBridge();
+const outcome = await auth.signIn({
+  keycloak: { baseUrl: "https://account.example.com", realm: "main", clientId: "siwe-public" },
+  onboarding: { clientId: "wallet-onboarding", redirectUri: "myapp://auth" },
+});
+if (outcome.status === "signed-in") save(outcome.tokens);
+// "profile-incomplete": Keycloak's own login was opened in the system browser
+// to finish the profile; call signIn again once it redirects back.
+```
+
+`@multiplatform.one/web3/bridge` is the same bridge without wagmi, for a host
+that drives the page itself. Kotlin and Swift hosts implement
+[docs/bridge-protocol.md](docs/bridge-protocol.md), the versioned wire
+protocol.
+
 ## Usage
 
 ```tsx
@@ -155,6 +295,38 @@ export function App() {
 }
 ```
 
+## Keycloak direct login and onboarding
+
+`kc.directGrant({ clientId })` trades a wallet signature for tokens without a
+browser. A brand-new user, or a realm that later adds a required profile
+field, has required actions Keycloak cannot run on a direct grant: it answers
+400 "Account is not fully set up", which `login()` rejects as
+`ProfileIncompleteError` and `useDirectLogin` reports as
+`status: "profile-incomplete"`. Open the `url` of `kc.browserLoginUrl({
+clientId, redirectUri })` in the system browser or a WebView page, where
+Keycloak shows its own onboarding form, then call `signIn()` again once it
+redirects back.
+
+`browserLoginUrl` draws a fresh `state` and a PKCE S256 verifier on every call
+and returns `{ url, state, codeVerifier }`. Keep `state` and accept the
+redirect only when it matches; `codeVerifier` is for a caller that exchanges
+the code at `kc.tokenUrl`. The client needs `standardFlowEnabled` and the
+redirect URI registered exactly, with no wildcard. A direct-grant client does
+not qualify: mpo's `siwe-public` and `siws-public` have `standardFlowEnabled:
+false`, so mpo's realm carries a separate public client, `wallet-onboarding`
+(PKCE S256 required, redirect URIs `http://localhost:8000/wallet`,
+`http://localhost:3456/wallet` and `multiplatform-one://wallet`). The wallet
+screen in `features/wallet` takes this path on its own.
+
+```tsx
+const { status, signIn } = useDirectLogin(grant);
+if (status === "profile-incomplete") {
+  const login = kc.browserLoginUrl({ clientId: "wallet-onboarding", redirectUri: "app://auth" });
+  await saveState(login.state);
+  await Linking.openURL(login.url);
+}
+```
+
 ## License
 
 Apache-2.0

package/dist/cjs/bridge/AuthBridge.cjs

@@ -0,0 +1,124 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var AuthBridge_exports = {};
+__export(AuthBridge_exports, {
+  AuthBridge: () => AuthBridge
+});
+module.exports = __toCommonJS(AuthBridge_exports);
+var import_hosting = require("./hosting.cjs");
+var import_protocol = require("./protocol.cjs");
+class AuthBridge {
+  constructor(bridge, options) {
+    this.bridge = bridge;
+    this.options = options;
+  }
+  bridge;
+  options;
+  pending = null;
+  async signIn(params = {}, options = {}) {
+    const {
+      openOnboarding = true,
+      ...request
+    } = options;
+    const onboarding = params.onboarding ?? this.options.defaults?.onboarding;
+    const keycloak = this.keycloak(params.keycloak);
+    const result = await this.bridge.request("auth", "signIn", {
+      family: params.family ?? "eth",
+      keycloak,
+      ...(onboarding ? {
+        onboarding
+      } : {})
+    }, {
+      timeoutMs: this.options.signInTimeoutMs ?? 10 * 6e4,
+      ...request
+    });
+    if (result.status !== "profile-incomplete") {
+      this.pending = null;
+      return result;
+    }
+    if (!isAuthorizationUrl(result.browserLogin?.url, keycloak)) {
+      throw new import_protocol.BridgeRequestError(import_protocol.BridgeErrorCode.internal, "auth.signIn: the page's browser login is not the realm's authorization endpoint");
+    }
+    this.pending = result.browserLogin;
+    if (!openOnboarding) return {
+      ...result,
+      onboardingOpened: false
+    };
+    await this.options.openUrl(result.browserLogin.url);
+    return {
+      ...result,
+      onboardingOpened: true
+    };
+  }
+  async refresh(params = {}) {
+    const res = await this.bridge.request("auth", "refresh", {
+      keycloak: this.keycloak(params.keycloak),
+      ...(params.refreshToken ? {
+        refreshToken: params.refreshToken
+      } : {})
+    });
+    return res.tokens;
+  }
+  async logout(params = {}) {
+    await this.bridge.request("auth", "logout", {
+      keycloak: this.keycloak(params.keycloak),
+      ...(params.refreshToken ? {
+        refreshToken: params.refreshToken
+      } : {})
+    });
+  }
+  /** The browser login the last `profile-incomplete` answer carried, until a sign-in succeeds. */
+  get pendingOnboarding() {
+    return this.pending;
+  }
+  /**
+   * True when `url` is Keycloak sending the browser back from that onboarding
+   * (its `state` matches) with no `error`. A matching return, cancelled or
+   * not, ends the pending onboarding, so the same return never counts twice.
+   */
+  isOnboardingReturn(url) {
+    if (this.pending === null) return false;
+    const params = (0, import_hosting.queryParams)(url);
+    if (params.state !== this.pending.state) return false;
+    this.pending = null;
+    return params.error === void 0;
+  }
+  /** `tokensChanged` fires whenever the page's tokens for a realm and client change. */
+  onTokensChanged(handler) {
+    return this.bridge.on((ns, method, params) => {
+      if (ns === "auth" && method === "tokensChanged") handler(params);
+    });
+  }
+  keycloak(keycloak) {
+    const resolved = keycloak ?? this.options.defaults?.keycloak;
+    if (!resolved) {
+      throw new import_protocol.BridgeRequestError(import_protocol.BridgeErrorCode.invalidParams, "auth: pass keycloak { baseUrl, realm, clientId } or set it in the provider defaults");
+    }
+    return resolved;
+  }
+}
+function isAuthorizationUrl(url, keycloak) {
+  if (typeof url !== "string") return false;
+  const realmUrl = `${keycloak.baseUrl.replace(/\/+$/, "")}/realms/${encodeURIComponent(keycloak.realm)}`;
+  return url.startsWith(`${realmUrl}/protocol/openid-connect/auth?`);
+}

package/dist/cjs/bridge/AuthBridge.native.js

@@ -0,0 +1,186 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var AuthBridge_exports = {};
+__export(AuthBridge_exports, {
+  AuthBridge: () => AuthBridge
+});
+module.exports = __toCommonJS(AuthBridge_exports);
+var import_hosting = require("./hosting.native.js");
+var import_protocol = require("./protocol.native.js");
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var AuthBridge = /* @__PURE__ */function () {
+  "use strict";
+
+  function AuthBridge2(bridge, options) {
+    _class_call_check(this, AuthBridge2);
+    _define_property(this, "bridge", void 0);
+    _define_property(this, "options", void 0);
+    _define_property(this, "pending", void 0);
+    this.bridge = bridge;
+    this.options = options;
+    this.pending = null;
+  }
+  _create_class(AuthBridge2, [{
+    key: "signIn",
+    value: async function signIn() {
+      var params = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {},
+        options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      var _params_onboarding, _params_family, _this_options_signInTimeoutMs;
+      var _this_options_defaults, _result_browserLogin;
+      var {
+        openOnboarding = true,
+        ...request
+      } = options;
+      var onboarding = (_params_onboarding = params.onboarding) !== null && _params_onboarding !== void 0 ? _params_onboarding : (_this_options_defaults = this.options.defaults) === null || _this_options_defaults === void 0 ? void 0 : _this_options_defaults.onboarding;
+      var keycloak = this.keycloak(params.keycloak);
+      var result = await this.bridge.request("auth", "signIn", {
+        family: (_params_family = params.family) !== null && _params_family !== void 0 ? _params_family : "eth",
+        keycloak,
+        ...(onboarding ? {
+          onboarding
+        } : {})
+      }, {
+        timeoutMs: (_this_options_signInTimeoutMs = this.options.signInTimeoutMs) !== null && _this_options_signInTimeoutMs !== void 0 ? _this_options_signInTimeoutMs : 10 * 6e4,
+        ...request
+      });
+      if (result.status !== "profile-incomplete") {
+        this.pending = null;
+        return result;
+      }
+      if (!isAuthorizationUrl((_result_browserLogin = result.browserLogin) === null || _result_browserLogin === void 0 ? void 0 : _result_browserLogin.url, keycloak)) {
+        throw new import_protocol.BridgeRequestError(import_protocol.BridgeErrorCode.internal, "auth.signIn: the page's browser login is not the realm's authorization endpoint");
+      }
+      this.pending = result.browserLogin;
+      if (!openOnboarding) return {
+        ...result,
+        onboardingOpened: false
+      };
+      await this.options.openUrl(result.browserLogin.url);
+      return {
+        ...result,
+        onboardingOpened: true
+      };
+    }
+  }, {
+    key: "refresh",
+    value: async function refresh() {
+      var params = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      var res = await this.bridge.request("auth", "refresh", {
+        keycloak: this.keycloak(params.keycloak),
+        ...(params.refreshToken ? {
+          refreshToken: params.refreshToken
+        } : {})
+      });
+      return res.tokens;
+    }
+  }, {
+    key: "logout",
+    value: async function logout() {
+      var params = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      await this.bridge.request("auth", "logout", {
+        keycloak: this.keycloak(params.keycloak),
+        ...(params.refreshToken ? {
+          refreshToken: params.refreshToken
+        } : {})
+      });
+    }
+  }, {
+    key: "pendingOnboarding",
+    get: (/** The browser login the last `profile-incomplete` answer carried, until a sign-in succeeds. */
+    function get() {
+      return this.pending;
+    })
+  }, {
+    /**
+    * True when `url` is Keycloak sending the browser back from that onboarding
+    * (its `state` matches) with no `error`. A matching return, cancelled or
+    * not, ends the pending onboarding, so the same return never counts twice.
+    */
+    key: "isOnboardingReturn",
+    value: function isOnboardingReturn(url) {
+      if (this.pending === null) return false;
+      var params = (0, import_hosting.queryParams)(url);
+      if (params.state !== this.pending.state) return false;
+      this.pending = null;
+      return params.error === void 0;
+    }
+  }, {
+    /** `tokensChanged` fires whenever the page's tokens for a realm and client change. */
+    key: "onTokensChanged",
+    value: function onTokensChanged(handler) {
+      return this.bridge.on(function (ns, method, params) {
+        if (ns === "auth" && method === "tokensChanged") handler(params);
+      });
+    }
+  }, {
+    key: "keycloak",
+    value: function keycloak(keycloak) {
+      var _this_options_defaults;
+      var resolved = keycloak !== null && keycloak !== void 0 ? keycloak : (_this_options_defaults = this.options.defaults) === null || _this_options_defaults === void 0 ? void 0 : _this_options_defaults.keycloak;
+      if (!resolved) {
+        throw new import_protocol.BridgeRequestError(import_protocol.BridgeErrorCode.invalidParams, "auth: pass keycloak { baseUrl, realm, clientId } or set it in the provider defaults");
+      }
+      return resolved;
+    }
+  }]);
+  return AuthBridge2;
+}();
+function isAuthorizationUrl(url, keycloak) {
+  if (typeof url !== "string") return false;
+  var realmUrl = `${keycloak.baseUrl.replace(/\/+$/, "")}/realms/${encodeURIComponent(keycloak.realm)}`;
+  return url.startsWith(`${realmUrl}/protocol/openid-connect/auth?`);
+}
+//# sourceMappingURL=AuthBridge.native.js.map

package/dist/cjs/bridge/AuthBridge.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","AuthBridge_exports","__export","AuthBridge","module","exports","import_hosting","require","import_protocol","_class_call_check","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_create_class","protoProps","staticProps","prototype","_define_property","obj","AuthBridge2","bridge","options","pending","signIn","params","arguments","_params_onboarding","_params_family","_this_options_signInTimeoutMs","_this_options_defaults","_result_browserLogin","openOnboarding","request","onboarding","defaults","keycloak","result","family","timeoutMs","signInTimeoutMs","status","isAuthorizationUrl","browserLogin","url","BridgeRequestError","BridgeErrorCode","internal","onboardingOpened","openUrl","refresh","res"],"sources":["../../../src/bridge/AuthBridge.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/bridge/BridgeClient.cjs

@@ -80,15 +80,20 @@ class BridgeClient {
       this.listeners.delete(handler);
     };
   }
-  /** Reject all in-flight requests — call on WebView reload/crash. */
+  /** Fail every request in flight and keep the client usable: the page they went to is gone. */
+  rejectPending(reason) {
+    const pending = Array.from(this.pending.values());
+    this.pending.clear();
+    for (const p of pending) {
+      p.cleanup();
+      p.reject(reason);
+    }
+  }
+  /** Reject all in-flight requests and stop listening. */
   dispose() {
     this.disposed = true;
     this.unsubscribe();
-    for (const [, p] of this.pending) {
-      p.cleanup();
-      p.reject(new Error("Bridge disposed"));
-    }
-    this.pending.clear();
+    this.rejectPending(new Error("Bridge disposed"));
     this.listeners.clear();
   }
   settle(id, reject, error) {
@@ -115,7 +120,5 @@ class BridgeClient {
   };
 }
 function toError(e) {
-  const err = new Error(e.message);
-  err.code = e.code;
-  return err;
+  return new import_protocol.BridgeRequestError(e.code, e.message, e.data);
 }

package/dist/cjs/bridge/BridgeClient.native.js

@@ -173,19 +173,19 @@ var BridgeClient = /* @__PURE__ */function () {
       };
     }
   }, {
-    /** Reject all in-flight requests — call on WebView reload/crash. */
-    key: "dispose",
-    value: function dispose() {
-      this.disposed = true;
-      this.unsubscribe();
+    /** Fail every request in flight and keep the client usable: the page they went to is gone. */
+    key: "rejectPending",
+    value: function rejectPending(reason) {
+      var pending = Array.from(this.pending.values());
+      this.pending.clear();
       var _iteratorNormalCompletion = true,
         _didIteratorError = false,
         _iteratorError = void 0;
       try {
-        for (var _iterator = this.pending[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var [, p] = _step.value;
+        for (var _iterator = pending[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var p = _step.value;
           p.cleanup();
-          p.reject(new Error("Bridge disposed"));
+          p.reject(reason);
         }
       } catch (err) {
         _didIteratorError = true;
@@ -201,7 +201,14 @@ var BridgeClient = /* @__PURE__ */function () {
           }
         }
       }
-      this.pending.clear();
+    }
+  }, {
+    /** Reject all in-flight requests and stop listening. */
+    key: "dispose",
+    value: function dispose() {
+      this.disposed = true;
+      this.unsubscribe();
+      this.rejectPending(new Error("Bridge disposed"));
       this.listeners.clear();
     }
   }, {
@@ -217,8 +224,6 @@ var BridgeClient = /* @__PURE__ */function () {
   return BridgeClient2;
 }();
 function toError(e) {
-  var err = new Error(e.message);
-  err.code = e.code;
-  return err;
+  return new import_protocol.BridgeRequestError(e.code, e.message, e.data);
 }
 //# sourceMappingURL=BridgeClient.native.js.map