@asseteragmbh/wallet-connector 0.1.0

package/dist/protocol.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The pop-up protocol between a partner page (the opener) and the Assetera Wallet (the pop-up) — ADR-0054 D3/D4.
+ *
+ * This file is the CONTRACT. The connector in this package speaks the opener side; AsseteraWalletFront's
+ * `/connect` page speaks the pop-up side and imports these types from `@asseteragmbh/wallet-connector/protocol`.
+ * Change it only in a backwards-compatible way, or bump `PROTOCOL_VERSION` and support both on the wallet side:
+ * partner sites upgrade on their own schedule.
+ *
+ * ## The handshake
+ *
+ * 1. The partner opens `${walletUrl}${CONNECT_PATH}?origin=<partner origin>&v=<version>` from a user click.
+ * 2. The pop-up checks the claimed origin against its allowlist (D4). If listed, it posts `ready` to
+ *    `window.opener` with `targetOrigin` = that origin. The browser delivers it ONLY if the opener really is
+ *    that origin, so a page cannot claim someone else's origin and still hear the answer.
+ * 3. The opener waits for `ready` from the wallet origin, then sends `request`s with `targetOrigin` = the wallet
+ *    origin. The pop-up accepts a message only when `event.origin` is the allowed origin from step 2 AND
+ *    `event.source === window.opener`, and answers with `targetOrigin` = that origin. Nothing else is accepted.
+ *
+ * ## Lifetime
+ *
+ * The pop-up stays open while the partner uses the wallet (ADR-0054, "the wallet tab must stay open"). When it is
+ * closed, the opener sees `disconnect` (or notices `popup.closed`) and must reconnect from a user click.
+ */
+declare const PROTOCOL_VERSION: 1;
+/** The pop-up route on the wallet origin. */
+declare const CONNECT_PATH = "/connect";
+/** Every message carries this prefix in `type`, so both sides can ignore unrelated `postMessage` traffic. */
+declare const MESSAGE_PREFIX: "assetera-wallet:";
+/**
+ * The EIP-1193 methods the pop-up answers (ADR-0054 D3). Anything else is refused with 4200. Read-only chain
+ * calls (`eth_call`, `eth_getBalance`, …) do not go through the pop-up; wagmi sends them to its own transports.
+ */
+declare const SUPPORTED_METHODS: readonly ["eth_requestAccounts", "eth_accounts", "eth_chainId", "wallet_switchEthereumChain", "personal_sign", "eth_signTypedData_v4", "eth_sendTransaction"];
+type SupportedMethod = (typeof SUPPORTED_METHODS)[number];
+declare function isSupportedMethod(method: string): method is SupportedMethod;
+/** EIP-1193 / EIP-1474 error codes the pop-up uses. */
+declare const RpcErrorCode: {
+    /** The client rejected the request in the pop-up. */
+    readonly UserRejected: 4001;
+    /** Not connected yet (no `eth_requestAccounts` approved in this pop-up). */
+    readonly Unauthorized: 4100;
+    /** The method is not in SUPPORTED_METHODS. */
+    readonly UnsupportedMethod: 4200;
+    /** The pop-up closed, or the wallet session ended. */
+    readonly Disconnected: 4900;
+    /** `wallet_switchEthereumChain` to a chain the wallet does not offer. */
+    readonly UnrecognizedChain: 4902;
+    /** Malformed params. */
+    readonly InvalidParams: -32602;
+    /** Anything unexpected inside the wallet. */
+    readonly Internal: -32603;
+};
+type RpcErrorCode = (typeof RpcErrorCode)[keyof typeof RpcErrorCode];
+interface RpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/** The pop-up is loaded and accepts requests from this opener. */
+interface ReadyMessage {
+    type: `${typeof MESSAGE_PREFIX}ready`;
+    v: typeof PROTOCOL_VERSION;
+    /** Shown to the partner for diagnostics only; the partner must not rely on it for anything. */
+    walletVersion?: string;
+}
+/** The answer to one `request`, matched by `id`. Exactly one of `result` / `error`. */
+type ResponseMessage = {
+    type: `${typeof MESSAGE_PREFIX}response`;
+    v: typeof PROTOCOL_VERSION;
+    id: string;
+    result: unknown;
+} | {
+    type: `${typeof MESSAGE_PREFIX}response`;
+    v: typeof PROTOCOL_VERSION;
+    id: string;
+    error: RpcError;
+};
+/** EIP-1193 provider events, forwarded to the partner. */
+type EventMessage = {
+    type: `${typeof MESSAGE_PREFIX}event`;
+    v: typeof PROTOCOL_VERSION;
+    event: "accountsChanged";
+    data: `0x${string}`[];
+} | {
+    type: `${typeof MESSAGE_PREFIX}event`;
+    v: typeof PROTOCOL_VERSION;
+    event: "chainChanged";
+    data: `0x${string}`;
+} | {
+    type: `${typeof MESSAGE_PREFIX}event`;
+    v: typeof PROTOCOL_VERSION;
+    event: "disconnect";
+    data: RpcError;
+};
+type WalletToPartnerMessage = ReadyMessage | ResponseMessage | EventMessage;
+interface RequestMessage {
+    type: `${typeof MESSAGE_PREFIX}request`;
+    v: typeof PROTOCOL_VERSION;
+    /** Unique per request within one connection; the response carries it back. */
+    id: string;
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+}
+/** The partner disconnects (for example the user clicked "Disconnect" in the partner page). */
+interface DisconnectMessage {
+    type: `${typeof MESSAGE_PREFIX}disconnect`;
+    v: typeof PROTOCOL_VERSION;
+}
+type PartnerToWalletMessage = RequestMessage | DisconnectMessage;
+declare function isReadyMessage(value: unknown): value is ReadyMessage;
+declare function isResponseMessage(value: unknown): value is ResponseMessage;
+declare function isEventMessage(value: unknown): value is EventMessage;
+declare function isRequestMessage(value: unknown): value is RequestMessage;
+declare function isDisconnectMessage(value: unknown): value is DisconnectMessage;
+/** The URL the partner opens. `partnerOrigin` is `window.location.origin` of the partner page. */
+declare function connectUrl(walletUrl: string, partnerOrigin: string): string;
+
+export { CONNECT_PATH, type DisconnectMessage, type EventMessage, MESSAGE_PREFIX, PROTOCOL_VERSION, type PartnerToWalletMessage, type ReadyMessage, type RequestMessage, type ResponseMessage, type RpcError, RpcErrorCode, SUPPORTED_METHODS, type SupportedMethod, type WalletToPartnerMessage, connectUrl, isDisconnectMessage, isEventMessage, isReadyMessage, isRequestMessage, isResponseMessage, isSupportedMethod };

package/dist/protocol.js

@@ -0,0 +1,3 @@
+export { CONNECT_PATH, MESSAGE_PREFIX, PROTOCOL_VERSION, RpcErrorCode, SUPPORTED_METHODS, connectUrl, isDisconnectMessage, isEventMessage, isReadyMessage, isRequestMessage, isResponseMessage, isSupportedMethod } from './chunk-N6D53D3G.js';
+//# sourceMappingURL=protocol.js.map
+//# sourceMappingURL=protocol.js.map

package/dist/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"protocol.js"}

package/dist/provider-BEIsX3q_.d.cts

@@ -0,0 +1,46 @@
+/** Arguments accepted by `request`, mirroring EIP-1193. */
+interface RequestArguments {
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+}
+/** EIP-1193 provider events emitted by the pop-up. */
+type ProviderEvent = "accountsChanged" | "chainChanged" | "connect" | "disconnect";
+/**
+ * Listener shape for EIP-1193 provider events. `never[]` accepts a listener with any concrete parameter list
+ * (for example wagmi's `(accounts: string[]) => void`), while internal emission stays type-safe via a cast.
+ */
+type ProviderListener = (...args: never[]) => void;
+/** The EIP-1193 surface returned by {@link createAsseteraWalletProvider}. */
+interface AsseteraWalletProvider {
+    request(args: RequestArguments): Promise<unknown>;
+    on(event: ProviderEvent, listener: ProviderListener): void;
+    removeListener(event: ProviderEvent, listener: ProviderListener): void;
+    disconnect(): void;
+}
+/** Options for {@link createAsseteraWalletProvider}. */
+interface AsseteraWalletProviderOptions {
+    /** Base URL of the wallet origin, e.g. `https://wallet.playground.assetera.com`. */
+    walletUrl: string;
+    /** Chain id used before the wallet reports one, and as the local `eth_chainId` fallback. */
+    defaultChainId: number;
+    /** `window.open` feature string. Defaults to `"popup,width=420,height=720"`. */
+    popupFeatures?: string;
+}
+/**
+ * EIP-1193 error carrying a JSON-RPC `code` (and optional `data`). This is what every rejected `request`
+ * throws, so wagmi maps the wallet's `4001` / `4100` / `4200` / `4900` correctly.
+ */
+declare class ProviderRpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+/**
+ * Create the EIP-1193 provider that talks to the Assetera Wallet pop-up.
+ *
+ * Call `request` from a user gesture: `eth_requestAccounts` opens the pop-up synchronously (before any
+ * `await`) so the browser treats it as part of the click and does not block it.
+ */
+declare function createAsseteraWalletProvider(options: AsseteraWalletProviderOptions): AsseteraWalletProvider;
+
+export { type AsseteraWalletProvider as A, type ProviderEvent as P, type RequestArguments as R, type AsseteraWalletProviderOptions as a, type ProviderListener as b, ProviderRpcError as c, createAsseteraWalletProvider as d };

package/dist/provider-BEIsX3q_.d.ts

@@ -0,0 +1,46 @@
+/** Arguments accepted by `request`, mirroring EIP-1193. */
+interface RequestArguments {
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+}
+/** EIP-1193 provider events emitted by the pop-up. */
+type ProviderEvent = "accountsChanged" | "chainChanged" | "connect" | "disconnect";
+/**
+ * Listener shape for EIP-1193 provider events. `never[]` accepts a listener with any concrete parameter list
+ * (for example wagmi's `(accounts: string[]) => void`), while internal emission stays type-safe via a cast.
+ */
+type ProviderListener = (...args: never[]) => void;
+/** The EIP-1193 surface returned by {@link createAsseteraWalletProvider}. */
+interface AsseteraWalletProvider {
+    request(args: RequestArguments): Promise<unknown>;
+    on(event: ProviderEvent, listener: ProviderListener): void;
+    removeListener(event: ProviderEvent, listener: ProviderListener): void;
+    disconnect(): void;
+}
+/** Options for {@link createAsseteraWalletProvider}. */
+interface AsseteraWalletProviderOptions {
+    /** Base URL of the wallet origin, e.g. `https://wallet.playground.assetera.com`. */
+    walletUrl: string;
+    /** Chain id used before the wallet reports one, and as the local `eth_chainId` fallback. */
+    defaultChainId: number;
+    /** `window.open` feature string. Defaults to `"popup,width=420,height=720"`. */
+    popupFeatures?: string;
+}
+/**
+ * EIP-1193 error carrying a JSON-RPC `code` (and optional `data`). This is what every rejected `request`
+ * throws, so wagmi maps the wallet's `4001` / `4100` / `4200` / `4900` correctly.
+ */
+declare class ProviderRpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+/**
+ * Create the EIP-1193 provider that talks to the Assetera Wallet pop-up.
+ *
+ * Call `request` from a user gesture: `eth_requestAccounts` opens the pop-up synchronously (before any
+ * `await`) so the browser treats it as part of the click and does not block it.
+ */
+declare function createAsseteraWalletProvider(options: AsseteraWalletProviderOptions): AsseteraWalletProvider;
+
+export { type AsseteraWalletProvider as A, type ProviderEvent as P, type RequestArguments as R, type AsseteraWalletProviderOptions as a, type ProviderListener as b, ProviderRpcError as c, createAsseteraWalletProvider as d };

package/dist/rainbowkit.cjs

@@ -0,0 +1,446 @@
+'use strict';
+
+var core = require('@wagmi/core');
+var viem = require('viem');
+
+// src/rainbowkit.ts
+
+// src/icon.ts
+var ICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" width="128" height="128" viewBox="0 0 128 128" fill="none"><rect width="128" height="128" rx="28" fill="#1a1a2e"/><path fill="#ffffff" fill-rule="evenodd" d="M64 24 100 104H80.5L73.6 86H54.4L47.5 104H28L64 24Zm-4.5 44.5h9L64 54.4 59.5 68.5Z"/></svg>';
+var ASSETERA_WALLET_ICON = `data:image/svg+xml,${encodeURIComponent(ICON_SVG)}`;
+
+// src/protocol.ts
+var PROTOCOL_VERSION = 1;
+var CONNECT_PATH = "/connect";
+var MESSAGE_PREFIX = "assetera-wallet:";
+var SUPPORTED_METHODS = [
+  "eth_requestAccounts",
+  "eth_accounts",
+  "eth_chainId",
+  "wallet_switchEthereumChain",
+  "personal_sign",
+  "eth_signTypedData_v4",
+  "eth_sendTransaction"
+];
+function isSupportedMethod(method) {
+  return SUPPORTED_METHODS.includes(method);
+}
+var RpcErrorCode = {
+  /** Not connected yet (no `eth_requestAccounts` approved in this pop-up). */
+  Unauthorized: 4100,
+  /** The method is not in SUPPORTED_METHODS. */
+  UnsupportedMethod: 4200,
+  /** The pop-up closed, or the wallet session ended. */
+  Disconnected: 4900};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasType(value, suffix) {
+  return isRecord(value) && value.type === `${MESSAGE_PREFIX}${suffix}` && value.v === PROTOCOL_VERSION;
+}
+function isReadyMessage(value) {
+  return hasType(value, "ready");
+}
+function isResponseMessage(value) {
+  return hasType(value, "response") && typeof value.id === "string" && ("result" in value || isRecord(value.error) && typeof value.error.code === "number");
+}
+function isEventMessage(value) {
+  return hasType(value, "event") && (value.event === "accountsChanged" || value.event === "chainChanged" || value.event === "disconnect");
+}
+function connectUrl(walletUrl, partnerOrigin) {
+  const url = new URL(CONNECT_PATH, walletUrl);
+  url.searchParams.set("origin", partnerOrigin);
+  url.searchParams.set("v", String(PROTOCOL_VERSION));
+  return url.toString();
+}
+
+// src/provider.ts
+var ProviderRpcError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "ProviderRpcError";
+    this.code = code;
+    this.data = data;
+  }
+};
+var DEFAULT_POPUP_FEATURES = "popup,width=420,height=720";
+var POPUP_NAME = "assetera-wallet";
+var CLOSE_POLL_MS = 500;
+var SIGNING_METHODS = /* @__PURE__ */ new Set([
+  "personal_sign",
+  "eth_signTypedData_v4",
+  "eth_sendTransaction"
+]);
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  void promise.catch(() => {
+  });
+  return { promise, resolve, reject };
+}
+function toHexChainId(chainId) {
+  return `0x${chainId.toString(16)}`;
+}
+function createAsseteraWalletProvider(options) {
+  const { defaultChainId } = options;
+  const walletOrigin = new URL(options.walletUrl).origin;
+  const popupFeatures = options.popupFeatures ?? DEFAULT_POPUP_FEATURES;
+  let popup = null;
+  let ready = createDeferred();
+  let accounts = [];
+  let chainIdHex = null;
+  let walletDisconnected = false;
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  let closeTimer = null;
+  function currentChainId() {
+    return chainIdHex ?? toHexChainId(defaultChainId);
+  }
+  function blockedError() {
+    return new ProviderRpcError(
+      RpcErrorCode.Disconnected,
+      "The Assetera Wallet pop-up was blocked by the browser. The pop-up must be opened from a user click (for example a button press) and then the request retried."
+    );
+  }
+  function disconnectedError(message = "The Assetera Wallet pop-up was closed.") {
+    return new ProviderRpcError(RpcErrorCode.Disconnected, message);
+  }
+  function emit(event, ...args) {
+    const set = listeners.get(event);
+    if (!set) return;
+    for (const listener of set) {
+      try {
+        listener(...args);
+      } catch (error) {
+        console.error(`[assetera-wallet] listener for "${event}" threw`, error);
+      }
+    }
+  }
+  function addListener(event, listener) {
+    let set = listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      listeners.set(event, set);
+    }
+    set.add(listener);
+  }
+  function removeEventListener(event, listener) {
+    listeners.get(event)?.delete(listener);
+  }
+  function stopClosePolling() {
+    if (closeTimer !== null) {
+      clearInterval(closeTimer);
+      closeTimer = null;
+    }
+  }
+  function startClosePolling() {
+    if (closeTimer !== null) return;
+    closeTimer = setInterval(() => {
+      if (popup?.closed) handlePopupClosed();
+    }, CLOSE_POLL_MS);
+  }
+  function rejectAllPending(error) {
+    for (const request2 of pending.values()) request2.reject(error);
+    pending.clear();
+  }
+  function handlePopupClosed() {
+    const hadPending = pending.size > 0;
+    stopClosePolling();
+    const closedPopup = popup;
+    popup = null;
+    const closedReady = ready;
+    ready = createDeferred();
+    const error = disconnectedError();
+    if (closedPopup) closedReady.reject(error);
+    rejectAllPending(error);
+    const shouldEmit = hadPending || walletDisconnected;
+    walletDisconnected = false;
+    if (shouldEmit) emit("disconnect", error);
+  }
+  function openPopup() {
+    if (popup && !popup.closed) {
+      popup.focus();
+      return popup;
+    }
+    if (typeof window === "undefined") return null;
+    const opened = window.open(
+      connectUrl(options.walletUrl, window.location.origin),
+      POPUP_NAME,
+      popupFeatures
+    );
+    if (!opened) return null;
+    popup = opened;
+    ready = createDeferred();
+    walletDisconnected = false;
+    startClosePolling();
+    return opened;
+  }
+  function sendRequest(method, params) {
+    const active = popup;
+    if (!active || active.closed) return Promise.reject(disconnectedError());
+    const id = crypto.randomUUID();
+    const message = {
+      type: `${MESSAGE_PREFIX}request`,
+      v: PROTOCOL_VERSION,
+      id,
+      method,
+      ...params === void 0 ? {} : { params }
+    };
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      active.postMessage(message, walletOrigin);
+    });
+  }
+  function handleResponse(message) {
+    const request2 = pending.get(message.id);
+    if (!request2) return;
+    pending.delete(message.id);
+    if ("error" in message) {
+      request2.reject(new ProviderRpcError(message.error.code, message.error.message, message.error.data));
+    } else {
+      request2.resolve(message.result);
+    }
+  }
+  function handleEventMessage(message) {
+    if (message.event === "accountsChanged") {
+      accounts = [...message.data];
+      emit("accountsChanged", [...accounts]);
+      return;
+    }
+    if (message.event === "chainChanged") {
+      chainIdHex = message.data;
+      emit("chainChanged", chainIdHex);
+      return;
+    }
+    walletDisconnected = true;
+    emit("disconnect", new ProviderRpcError(message.data.code, message.data.message, message.data.data));
+  }
+  function onWindowMessage(event) {
+    if (event.origin !== walletOrigin) return;
+    if (popup === null || event.source !== popup) return;
+    const data = event.data;
+    if (isReadyMessage(data)) {
+      ready.resolve(void 0);
+      return;
+    }
+    if (isResponseMessage(data)) {
+      handleResponse(data);
+      return;
+    }
+    if (isEventMessage(data)) handleEventMessage(data);
+  }
+  if (typeof window !== "undefined") window.addEventListener("message", onWindowMessage);
+  function request({ method, params }) {
+    if (typeof window === "undefined") {
+      return Promise.reject(
+        new ProviderRpcError(
+          RpcErrorCode.Disconnected,
+          "The Assetera Wallet provider can only run in a browser."
+        )
+      );
+    }
+    if (!isSupportedMethod(method)) {
+      return Promise.reject(
+        new ProviderRpcError(
+          RpcErrorCode.UnsupportedMethod,
+          `The Assetera Wallet pop-up does not support the method "${method}".`
+        )
+      );
+    }
+    if (method === "eth_accounts") return Promise.resolve([...accounts]);
+    if (method === "eth_chainId") return Promise.resolve(currentChainId());
+    if (method === "eth_requestAccounts") {
+      const active2 = openPopup();
+      if (!active2) return Promise.reject(blockedError());
+      return ready.promise.then(() => sendRequest("eth_requestAccounts", params)).then((result) => {
+        accounts = Array.isArray(result) ? result : [];
+        emit("accountsChanged", [...accounts]);
+        emit("connect", { chainId: currentChainId() });
+        return [...accounts];
+      });
+    }
+    if (accounts.length === 0) {
+      return Promise.reject(
+        new ProviderRpcError(
+          RpcErrorCode.Unauthorized,
+          "Connect to the Assetera Wallet first (eth_requestAccounts)."
+        )
+      );
+    }
+    const active = openPopup();
+    if (!active) return Promise.reject(blockedError());
+    if (SIGNING_METHODS.has(method)) active.focus();
+    return ready.promise.then(() => sendRequest(method, params));
+  }
+  function disconnect() {
+    const active = popup;
+    if (active && !active.closed) {
+      const message = {
+        type: `${MESSAGE_PREFIX}disconnect`,
+        v: PROTOCOL_VERSION
+      };
+      active.postMessage(message, walletOrigin);
+      active.close();
+    }
+    stopClosePolling();
+    popup = null;
+    const closedReady = ready;
+    ready = createDeferred();
+    closedReady.reject(disconnectedError("Disconnected from the Assetera Wallet."));
+    rejectAllPending(disconnectedError("Disconnected from the Assetera Wallet."));
+    accounts = [];
+    chainIdHex = null;
+    walletDisconnected = false;
+    emit("disconnect", disconnectedError("Disconnected from the Assetera Wallet."));
+  }
+  function on(event, listener) {
+    addListener(event, listener);
+  }
+  function removeListener(event, listener) {
+    removeEventListener(event, listener);
+  }
+  return { request, on, removeListener, disconnect };
+}
+
+// src/wagmi.ts
+var ASSETERA_WALLET_ID = "assetera-wallet";
+var ASSETERA_WALLET_NAME = "Assetera Wallet";
+var ASSETERA_WALLET_TYPE = "asseteraWallet";
+function asseteraWallet(parameters) {
+  let provider;
+  let accountsChanged;
+  let chainChanged;
+  let disconnectHandler;
+  function removeProviderListeners(activeProvider) {
+    if (accountsChanged) {
+      activeProvider.removeListener("accountsChanged", accountsChanged);
+      accountsChanged = void 0;
+    }
+    if (chainChanged) {
+      activeProvider.removeListener("chainChanged", chainChanged);
+      chainChanged = void 0;
+    }
+    if (disconnectHandler) {
+      activeProvider.removeListener("disconnect", disconnectHandler);
+      disconnectHandler = void 0;
+    }
+  }
+  return core.createConnector((config) => ({
+    id: ASSETERA_WALLET_ID,
+    name: ASSETERA_WALLET_NAME,
+    type: ASSETERA_WALLET_TYPE,
+    icon: ASSETERA_WALLET_ICON,
+    async connect({ chainId, withCapabilities } = {}) {
+      const activeProvider = await this.getProvider();
+      const requested = await activeProvider.request({
+        method: "eth_requestAccounts"
+      });
+      const addresses = requested.map((account) => viem.getAddress(account));
+      if (!accountsChanged) {
+        accountsChanged = this.onAccountsChanged.bind(this);
+        activeProvider.on("accountsChanged", accountsChanged);
+      }
+      if (!chainChanged) {
+        chainChanged = this.onChainChanged.bind(this);
+        activeProvider.on("chainChanged", chainChanged);
+      }
+      if (!disconnectHandler) {
+        disconnectHandler = this.onDisconnect.bind(this);
+        activeProvider.on("disconnect", disconnectHandler);
+      }
+      let currentChainId = await this.getChainId();
+      if (chainId && currentChainId !== chainId) {
+        const chain = await this.switchChain({ chainId }).catch((error) => {
+          if (error?.code === viem.UserRejectedRequestError.code) throw error;
+          return { id: currentChainId };
+        });
+        currentChainId = chain?.id ?? currentChainId;
+      }
+      return {
+        accounts: withCapabilities ? addresses.map((address) => ({ address, capabilities: {} })) : addresses,
+        chainId: currentChainId
+      };
+    },
+    async disconnect() {
+      if (!provider) return;
+      removeProviderListeners(provider);
+      provider.disconnect();
+    },
+    async getAccounts() {
+      const activeProvider = await this.getProvider();
+      const requested = await activeProvider.request({ method: "eth_accounts" });
+      return requested.map((account) => viem.getAddress(account));
+    },
+    async getChainId() {
+      const activeProvider = await this.getProvider();
+      return Number(await activeProvider.request({ method: "eth_chainId" }));
+    },
+    async getProvider() {
+      if (!provider) {
+        provider = createAsseteraWalletProvider({
+          walletUrl: parameters.walletUrl,
+          defaultChainId: config.chains[0].id
+        });
+      }
+      return provider;
+    },
+    /**
+     * Always `false`: opening the pop-up requires a user click, so there is nothing to reconnect to on page
+     * load. Returning `true` would make wagmi attempt an automatic reconnect that the browser blocks; the
+     * partner app must drive `connect()` from a click instead.
+     */
+    async isAuthorized() {
+      return false;
+    },
+    async switchChain({ chainId }) {
+      const chain = config.chains.find((candidate) => candidate.id === chainId);
+      if (!chain) throw new core.ChainNotConfiguredError();
+      const activeProvider = await this.getProvider();
+      await activeProvider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: viem.numberToHex(chainId) }]
+      });
+      this.onChainChanged(viem.numberToHex(chainId));
+      return chain;
+    },
+    onAccountsChanged(accounts) {
+      if (accounts.length === 0) this.onDisconnect();
+      else
+        config.emitter.emit("change", {
+          accounts: accounts.map((account) => viem.getAddress(account))
+        });
+    },
+    onChainChanged(chain) {
+      config.emitter.emit("change", { chainId: Number(chain) });
+    },
+    onDisconnect() {
+      config.emitter.emit("disconnect");
+      if (provider) removeProviderListeners(provider);
+    }
+  }));
+}
+
+// src/rainbowkit.ts
+function asseteraRainbowWallet(options) {
+  return () => ({
+    id: ASSETERA_WALLET_ID,
+    name: ASSETERA_WALLET_NAME,
+    iconUrl: ASSETERA_WALLET_ICON,
+    iconBackground: "#1a1a2e",
+    installed: true,
+    createConnector: (walletDetails) => core.createConnector((config) => ({
+      ...asseteraWallet({ walletUrl: options.walletUrl })(config),
+      ...walletDetails
+    }))
+  });
+}
+
+exports.asseteraRainbowWallet = asseteraRainbowWallet;
+//# sourceMappingURL=rainbowkit.cjs.map
+//# sourceMappingURL=rainbowkit.cjs.map