@chipi-stack/starknet-connector 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Connector } from '@starknet-react/core';
 import { ProviderInterface, AccountInterface } from 'starknet';
-import { StarknetWindowObject, RpcMessage, RequestFnCall, RpcTypeToMessageMap } from '@starknet-io/types-js';
+import { StarknetWindowObject, RpcMessage, RequestFnCall, RpcTypeToMessageMap, RequestFn } from '@starknet-io/types-js';
 
 /**
  * Wire protocol between the "Connect with Chipi" connector (running in the dApp)
@@ -68,7 +68,9 @@ declare function isChipiDappMessage(data: unknown): data is ChipiDappMessage;
  * Client-side (dApp) transport: opens the Chipi hosted wallet in a popup,
  * performs the ready handshake, and forwards get-starknet `wallet_*` RPC calls
  * over `postMessage`, correlating responses by id. The popup is reused across
- * requests; if the user closed it, the next request reopens it.
+ * requests. If the user closes it, later requests reject with `POPUP_CLOSED`
+ * instead of reopening it: `window.open` outside a click is blocked by
+ * browsers, so the dApp must call `connect()` (or `open()`) again from a click.
  */
 
 interface ChipiTransportOptions {
@@ -89,9 +91,19 @@ interface ChipiTransportOptions {
     windowName?: string;
     /** Popup window features. */
     windowFeatures?: string;
-    /** Ready-handshake timeout (ms). */
+    /** Ready-handshake timeout (ms). Defaults to 180_000. On timeout the popup is
+     * closed and the transport resets, so the next `open()` starts clean. */
     openTimeoutMs?: number;
+    /**
+     * Per-request timeout (ms), counted from when the request is posted to the
+     * wallet. Defaults to 120_000. A request that gets no answer in time rejects
+     * with an Error whose `code` (and `name`) is `"REQUEST_TIMEOUT"`. Pass `0` to
+     * disable.
+     */
+    requestTimeoutMs?: number;
 }
+/** Error codes the transport attaches to `Error.code` (besides wallet codes). */
+type ChipiTransportErrorCode = "REQUEST_TIMEOUT" | "POPUP_CLOSED";
 type EventName = "accountsChanged" | "networkChanged";
 type EventHandler = (data: unknown) => void;
 declare class ChipiPopupTransport {
@@ -107,6 +119,9 @@ declare class ChipiPopupTransport {
     private readyDeferred;
     private openPromise;
     private closeWatch;
+    /** True once this transport opened a popup. A later request with no live
+     * popup means the user closed it: reject instead of reopening off-gesture. */
+    private hadPopup;
     constructor(opts: ChipiTransportOptions);
     on(event: EventName, handler: EventHandler): void;
     off(event: EventName, handler: EventHandler): void;
@@ -118,6 +133,8 @@ declare class ChipiPopupTransport {
      * its ready handshake. Concurrent calls share ONE handshake. */
     open(): Promise<void>;
     private doOpen;
+    /** Close the popup (if we own one) and forget the target + ready state. */
+    private resetTarget;
     private awaitReady;
     /** Reject every in-flight request (popup closed / disconnected). */
     private rejectAllPending;
@@ -125,7 +142,15 @@ declare class ChipiPopupTransport {
      * reject them: otherwise the dApp's promise would hang forever. */
     private startCloseWatch;
     private stopCloseWatch;
-    /** Forward a get-starknet RPC call to the wallet, awaiting its response. */
+    /**
+     * Forward a get-starknet RPC call to the wallet, awaiting its response.
+     *
+     * The first request may open the popup. Once a popup has been opened, a
+     * request made after it was closed rejects with `code: "POPUP_CLOSED"`
+     * instead of calling `window.open` again: requests usually run outside a
+     * click, where browsers block popups. Reopen via `connect()` / `open()`
+     * from a click.
+     */
     request(call: ChipiRpcCall): Promise<unknown>;
     /** Close the popup (if we own one) + reject in-flight requests. */
     close(): void;
@@ -147,6 +172,10 @@ type ConnectorData = {
     account?: string;
     chainId?: bigint;
 };
+/** Mirrors starknet-react's `ConnectArgs` (not exported by every version). */
+type ConnectArgs = {
+    chainIdHint?: bigint;
+};
 interface ChipiConnectorOptions {
     /** Hosted wallet base URL. Defaults to `https://wallet.chipipay.com`. */
     walletUrl?: string;
@@ -173,6 +202,7 @@ declare class ChipiConnector extends Connector {
     private _account;
     private _swo;
     private _registration;
+    private readonly _autoRegister;
     constructor(options?: ChipiConnectorOptions);
     /**
      * Announce this wallet to scanning dApps (`window.starknet_chipi` +
@@ -191,8 +221,18 @@ declare class ChipiConnector extends Connector {
     ready(): Promise<boolean>;
     /** Lazily build the postMessage-backed get-starknet window object. */
     private swo;
-    connect(): Promise<ConnectorData>;
+    /**
+     * Open the hosted wallet (call from a click: it opens a popup) and request
+     * the account. Chipi is mainnet-only: a `chainIdHint` other than SN_MAIN
+     * rejects before any popup opens.
+     */
+    connect(args?: ConnectArgs): Promise<ConnectorData>;
     disconnect(): Promise<void>;
+    /** Forward the wallet's account/network events as starknet-react events. */
+    private subscribe;
+    private unsubscribe;
+    private onAccountsChanged;
+    private onNetworkChanged;
     private emitEvent;
     account(provider: ProviderInterface): Promise<AccountInterface>;
     chainId(): Promise<bigint>;
@@ -233,4 +273,100 @@ interface ChipiRegistration {
  */
 declare function registerChipiWallet(wallet: StarknetWindowObject, target?: (Window & typeof globalThis) | undefined): ChipiRegistration;
 
-export { CHIPI_WC, CHIPI_WINDOW_KEY, ChipiConnector, type ChipiConnectorOptions, type ChipiDappMessage, type ChipiEventMessage, ChipiPopupTransport, type ChipiReadyMessage, type ChipiRegistration, type ChipiRpcCall, type ChipiRpcRequestMessage, type ChipiRpcResultMessage, type ChipiTransportOptions, type ChipiWalletMessage, chipi, isChipiDappMessage, isChipiWalletMessage, registerChipiWallet };
+/**
+ * Chipi as a Wallet Standard wallet with Starknet features
+ * (`WalletWithStarknetFeatures` from `@starknet-io/get-starknet-wallet-standard`),
+ * so dApps on get-starknet v5+/v6 discovery (`@starknet-io/get-starknet-discovery`,
+ * `@starknet-start/react`, anything that listens for
+ * `wallet-standard:register-wallet`) list "Chipi" without importing this
+ * package's connector.
+ *
+ * Backed by the same popup transport as {@link ChipiConnector}. The types
+ * below mirror the upstream interfaces structurally so this package keeps no
+ * runtime (or type) dependency on `@wallet-standard/*`.
+ */
+
+/** Wallet Standard chain id for Starknet mainnet: `starknet:` + hex of "SN_MAIN"
+ * (same as `WELL_KNOWN_STARKNET_CHAINS[0]` in get-starknet-wallet-standard). */
+declare const CHIPI_STARKNET_MAINNET_CHAIN: "starknet:0x534e5f4d41494e";
+/** `starknet:0x...` chain identifier. */
+type ChipiStarknetChain = `starknet:0x${string}`;
+/** Data-URI icon, as Wallet Standard requires. */
+type ChipiWalletIcon = `data:image/${"svg+xml" | "webp" | "png" | "gif"};base64,${string}`;
+/** Mirrors `@wallet-standard/base` `WalletAccount`. */
+interface ChipiStandardWalletAccount {
+    readonly address: string;
+    readonly publicKey: Uint8Array;
+    readonly chains: readonly ChipiStarknetChain[];
+    readonly features: readonly `${string}:${string}`[];
+}
+/** Mirrors `@wallet-standard/features` `StandardEventsChangeProperties`. */
+interface ChipiStandardChangeProperties {
+    readonly chains?: readonly ChipiStarknetChain[];
+    readonly accounts?: readonly ChipiStandardWalletAccount[];
+}
+/** Mirrors `StarknetFeatures` from `@starknet-io/get-starknet-wallet-standard`.
+ * (A type alias, not an interface, so it satisfies Wallet Standard's
+ * `IdentifierRecord` index signature.) */
+type ChipiStandardWalletFeatures = {
+    readonly "starknet:walletApi": {
+        readonly version: "1.0.0";
+        readonly request: RequestFn;
+        readonly walletVersion: string;
+        readonly id: string;
+    };
+    readonly "standard:connect": {
+        readonly version: "1.0.0";
+        readonly connect: (input?: {
+            readonly silent?: boolean;
+        }) => Promise<{
+            readonly accounts: readonly ChipiStandardWalletAccount[];
+        }>;
+    };
+    readonly "standard:disconnect": {
+        readonly version: "1.0.0";
+        readonly disconnect: () => Promise<void>;
+    };
+    readonly "standard:events": {
+        readonly version: "1.0.0";
+        readonly on: <E extends "change">(event: E, listener: (properties: ChipiStandardChangeProperties) => void) => () => void;
+    };
+};
+/** Structurally a `WalletWithStarknetFeatures`. */
+interface ChipiStandardWallet {
+    readonly version: "1.0.0";
+    readonly name: string;
+    readonly icon: ChipiWalletIcon;
+    readonly chains: readonly ChipiStarknetChain[];
+    readonly accounts: readonly ChipiStandardWalletAccount[];
+    readonly features: ChipiStandardWalletFeatures;
+}
+interface ChipiStandardWalletOptions {
+    /** Hosted wallet base URL. Defaults to `https://wallet.chipipay.com`. */
+    walletUrl?: string;
+    /** Display name. Defaults to `"Chipi"`. */
+    name?: string;
+    /** Data-URI icon. Defaults to the Chipi icon. */
+    icon?: ChipiWalletIcon;
+    /** Popup transport tuning (window name/features, timeouts). */
+    transport?: Omit<ChipiTransportOptions, "walletUrl" | "mode">;
+}
+/**
+ * Build the Chipi Wallet Standard wallet (without registering it). `connect`
+ * opens the popup, so dApps call it from a click; `connect({ silent: true })`
+ * never opens a popup and returns the current accounts (empty if not
+ * connected).
+ */
+declare function createChipiStandardWallet(options?: ChipiStandardWalletOptions): ChipiStandardWallet;
+/**
+ * Register Chipi with every Wallet Standard app on the page: dispatches
+ * `wallet-standard:register-wallet` now and answers later
+ * `wallet-standard:app-ready` events (the `@wallet-standard/wallet`
+ * `registerWallet` protocol, implemented here without the dependency).
+ *
+ * Returns an unregister function that removes the listener and unregisters
+ * from every app that accepted the wallet. SSR-safe: a no-op without `window`.
+ */
+declare function registerChipiStandardWallet(options?: ChipiStandardWalletOptions, target?: (Window & typeof globalThis) | undefined): () => void;
+
+export { CHIPI_STARKNET_MAINNET_CHAIN, CHIPI_WC, CHIPI_WINDOW_KEY, ChipiConnector, type ChipiConnectorOptions, type ChipiDappMessage, type ChipiEventMessage, ChipiPopupTransport, type ChipiReadyMessage, type ChipiRegistration, type ChipiRpcCall, type ChipiRpcRequestMessage, type ChipiRpcResultMessage, type ChipiStandardChangeProperties, type ChipiStandardWallet, type ChipiStandardWalletAccount, type ChipiStandardWalletFeatures, type ChipiStandardWalletOptions, type ChipiStarknetChain, type ChipiTransportErrorCode, type ChipiTransportOptions, type ChipiWalletIcon, type ChipiWalletMessage, chipi, createChipiStandardWallet, isChipiDappMessage, isChipiWalletMessage, registerChipiStandardWallet, registerChipiWallet };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { Connector } from '@starknet-react/core';
-import { WalletAccount } from 'starknet';
+import { constants, WalletAccount } from 'starknet';
 
 // src/connector.ts
 
@@ -13,6 +13,22 @@ function isChipiDappMessage(data) {
 }
 
 // src/transport.ts
+function transportError(code, message) {
+  const err = Object.assign(new Error(message), { code });
+  err.name = code;
+  return err;
+}
+function stripUndefined(value) {
+  if (Array.isArray(value)) return value.map((v) => stripUndefined(v));
+  if (value === null || typeof value !== "object") return value;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return value;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (v !== void 0) out[k] = stripUndefined(v);
+  }
+  return out;
+}
 function deferred() {
   let resolve;
   let reject;
@@ -37,18 +53,19 @@ var ChipiPopupTransport = class {
     this.readyDeferred = null;
     this.openPromise = null;
     this.closeWatch = null;
+    /** True once this transport opened a popup. A later request with no live
+     * popup means the user closed it: reject instead of reopening off-gesture. */
+    this.hadPopup = false;
     this.onMessage = (e) => {
       if (e.origin !== this.walletOrigin || !isChipiWalletMessage(e.data)) return;
-      if (this.target && e.source !== this.target) return;
+      if (!this.target || e.source !== this.target) return;
       const msg = e.data;
       if (msg.type === "ready") {
         this.ready = true;
         this.readyDeferred?.resolve();
         this.readyDeferred = null;
-        if (this.target) {
-          for (const p of this.pending.values()) {
-            this.target.postMessage(p.message, this.walletOrigin);
-          }
+        for (const p of this.pending.values()) {
+          this.target.postMessage(p.message, this.walletOrigin);
         }
         return;
       }
@@ -56,6 +73,7 @@ var ChipiPopupTransport = class {
         const p = this.pending.get(msg.id);
         if (!p) return;
         this.pending.delete(msg.id);
+        if (p.timer) clearTimeout(p.timer);
         if (msg.ok) p.resolve(msg.result);
         else p.reject(Object.assign(new Error(msg.error.message), { code: msg.error.code }));
         return;
@@ -114,9 +132,26 @@ var ChipiPopupTransport = class {
       );
       this.ownsTarget = true;
       if (!this.target) throw Object.assign(new Error("Popup blocked"), { code: "popup_blocked" });
+      this.hadPopup = true;
     }
+    const opened = this.target;
     this.readyDeferred = deferred();
-    await this.awaitReady();
+    try {
+      await this.awaitReady();
+    } catch (err) {
+      if (this.target === opened) this.resetTarget();
+      throw err;
+    }
+  }
+  /** Close the popup (if we own one) and forget the target + ready state. */
+  resetTarget() {
+    try {
+      if (this.ownsTarget) this.target?.close();
+    } catch {
+    }
+    this.target = null;
+    this.ready = false;
+    this.readyDeferred = null;
   }
   async awaitReady() {
     const timeoutMs = this.opts.openTimeoutMs ?? 18e4;
@@ -132,7 +167,10 @@ var ChipiPopupTransport = class {
   }
   /** Reject every in-flight request (popup closed / disconnected). */
   rejectAllPending(message) {
-    for (const [, p] of this.pending) p.reject(Object.assign(new Error(message), { code: 4001 }));
+    for (const [, p] of this.pending) {
+      if (p.timer) clearTimeout(p.timer);
+      p.reject(Object.assign(new Error(message), { code: 4001 }));
+    }
     this.pending.clear();
   }
   /** While requests are in flight, watch for the user closing the popup and
@@ -156,8 +194,22 @@ var ChipiPopupTransport = class {
       this.closeWatch = null;
     }
   }
-  /** Forward a get-starknet RPC call to the wallet, awaiting its response. */
+  /**
+   * Forward a get-starknet RPC call to the wallet, awaiting its response.
+   *
+   * The first request may open the popup. Once a popup has been opened, a
+   * request made after it was closed rejects with `code: "POPUP_CLOSED"`
+   * instead of calling `window.open` again: requests usually run outside a
+   * click, where browsers block popups. Reopen via `connect()` / `open()`
+   * from a click.
+   */
   async request(call) {
+    if (this.hadPopup && this.resolveMode() === "popup" && (!this.target || this.target.closed)) {
+      throw transportError(
+        "POPUP_CLOSED",
+        "The Chipi wallet window was closed. Call connect() again from a click."
+      );
+    }
     await this.open();
     if (this.ownsTarget) this.target?.focus();
     const id = randomId();
@@ -166,10 +218,24 @@ var ChipiPopupTransport = class {
       type: "rpc",
       id,
       origin: window.location.origin,
-      call
+      call: stripUndefined(call)
     };
+    const timeoutMs = this.opts.requestTimeoutMs ?? 12e4;
     return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject, message });
+      const entry = { resolve, reject, message };
+      if (timeoutMs > 0 && Number.isFinite(timeoutMs)) {
+        entry.timer = setTimeout(() => {
+          if (this.pending.get(id) !== entry) return;
+          this.pending.delete(id);
+          reject(
+            transportError(
+              "REQUEST_TIMEOUT",
+              `The Chipi wallet did not answer "${call.type}" within ${timeoutMs} ms.`
+            )
+          );
+        }, timeoutMs);
+      }
+      this.pending.set(id, entry);
       this.target.postMessage(message, this.walletOrigin);
       this.startCloseWatch();
     });
@@ -177,12 +243,8 @@ var ChipiPopupTransport = class {
   /** Close the popup (if we own one) + reject in-flight requests. */
   close() {
     this.stopCloseWatch();
-    try {
-      if (this.ownsTarget) this.target?.close();
-    } catch {
-    }
-    this.target = null;
-    this.ready = false;
+    this.readyDeferred?.reject(Object.assign(new Error("disconnected"), { code: 4001 }));
+    this.resetTarget();
     this.rejectAllPending("disconnected");
     if (this.listening && typeof window !== "undefined") {
       window.removeEventListener("message", this.onMessage);
@@ -213,13 +275,46 @@ function registerChipiWallet(wallet, target = typeof window !== "undefined" ? wi
 var CHIPI_ICON = "data:image/png;base64,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";
 
 // src/connector.ts
-var SN_MAIN = BigInt("0x534e5f4d41494e");
+var SN_MAIN = BigInt(constants.StarknetChainId.SN_MAIN);
+function toChainId(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" || typeof value === "string") {
+    try {
+      return BigInt(value);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
 var ChipiConnector = class extends Connector {
   constructor(options = {}) {
     super();
     this._account = null;
     this._swo = null;
     this._registration = null;
+    this.onAccountsChanged = (data) => {
+      const accounts = Array.isArray(data) ? data : [];
+      const account = accounts[0];
+      if (typeof account === "string" && account) {
+        this._account = account;
+        this.emitEvent("change", { account, chainId: SN_MAIN });
+      } else {
+        this._account = null;
+        this.emitEvent("disconnect");
+      }
+    };
+    this.onNetworkChanged = (data) => {
+      const payload = typeof data === "object" && data !== null && !Array.isArray(data) ? data : { chainId: data };
+      const chainId = toChainId(payload.chainId);
+      const accounts = Array.isArray(payload.accounts) ? payload.accounts : [];
+      const next = typeof accounts[0] === "string" && accounts[0] ? accounts[0] : this._account;
+      if (next) this._account = next;
+      const change = {};
+      if (chainId !== void 0) change.chainId = chainId;
+      if (next) change.account = next;
+      this.emitEvent("change", change);
+    };
     const walletUrl = options.walletUrl ?? options.transport?.walletUrl ?? "https://wallet.chipipay.com";
     this.transport = new ChipiPopupTransport({
       ...options.transport,
@@ -230,7 +325,8 @@ var ChipiConnector = class extends Connector {
     this._id = options.id ?? "chipi";
     this._name = options.name ?? "Connect with Chipi";
     this._icon = options.icon ?? CHIPI_ICON;
-    if (options.register !== false) this.register();
+    this._autoRegister = options.register !== false;
+    if (this._autoRegister) this.register();
   }
   /**
    * Announce this wallet to scanning dApps (`window.starknet_chipi` +
@@ -284,7 +380,22 @@ var ChipiConnector = class extends Connector {
     };
     return this._swo;
   }
-  async connect() {
+  /**
+   * Open the hosted wallet (call from a click: it opens a popup) and request
+   * the account. Chipi is mainnet-only: a `chainIdHint` other than SN_MAIN
+   * rejects before any popup opens.
+   */
+  async connect(args = {}) {
+    if (args.chainIdHint !== void 0 && BigInt(args.chainIdHint) !== SN_MAIN) {
+      throw Object.assign(
+        new Error(
+          `Chipi is mainnet-only: chainIdHint 0x${BigInt(args.chainIdHint).toString(16)} is not SN_MAIN.`
+        ),
+        { code: "UNSUPPORTED_CHAIN" }
+      );
+    }
+    if (this._autoRegister) this.register();
+    this.subscribe();
     await this.transport.open();
     const accounts = await this.transport.request({ type: "wallet_requestAccounts" });
     const account = accounts?.[0];
@@ -295,16 +406,27 @@ var ChipiConnector = class extends Connector {
     return data;
   }
   async disconnect() {
+    this.unsubscribe();
     this.transport.close();
     this._account = null;
+    this.unregister();
     this._swo = null;
     this.emitEvent("disconnect");
   }
-  // `Connector` extends eventemitter3's EventEmitter, but the bundled .d.ts
-  // doesn't surface `emit` cleanly through the abstract class: reach it via a
-  // narrow cast rather than fight the upstream typing.
+  /** Forward the wallet's account/network events as starknet-react events. */
+  subscribe() {
+    this.unsubscribe();
+    this.transport.on("accountsChanged", this.onAccountsChanged);
+    this.transport.on("networkChanged", this.onNetworkChanged);
+  }
+  unsubscribe() {
+    this.transport.off("accountsChanged", this.onAccountsChanged);
+    this.transport.off("networkChanged", this.onNetworkChanged);
+  }
   emitEvent(event, data) {
-    this.emit(event, data);
+    const emitter = this;
+    if (data === void 0) emitter.emit(event);
+    else emitter.emit(event, data);
   }
   async account(provider) {
     if (!this._account) throw new Error("chipi_not_connected");
@@ -323,6 +445,144 @@ function chipi(options) {
   return new ChipiConnector(options);
 }
 
-export { CHIPI_WC, CHIPI_WINDOW_KEY, ChipiConnector, ChipiPopupTransport, chipi, isChipiDappMessage, isChipiWalletMessage, registerChipiWallet };
+// src/standard.ts
+var CHIPI_STARKNET_MAINNET_CHAIN = "starknet:0x534e5f4d41494e";
+function toStarknetChain(value) {
+  if (typeof value !== "string" && typeof value !== "bigint" && typeof value !== "number") {
+    return void 0;
+  }
+  try {
+    return `starknet:0x${BigInt(value).toString(16)}`;
+  } catch {
+    return void 0;
+  }
+}
+function createChipiStandardWallet(options = {}) {
+  const transport = new ChipiPopupTransport({
+    ...options.transport,
+    walletUrl: options.walletUrl ?? "https://wallet.chipipay.com",
+    mode: "popup"
+  });
+  const listeners = /* @__PURE__ */ new Set();
+  let current = null;
+  const accounts = () => current ? [
+    {
+      address: current.address,
+      publicKey: new Uint8Array(),
+      chains: [current.chain],
+      features: []
+    }
+  ] : [];
+  const emitChange = () => {
+    const properties = { accounts: accounts() };
+    for (const listener of [...listeners]) listener(properties);
+  };
+  const setDisconnected = () => {
+    if (!current) return;
+    current = null;
+    emitChange();
+  };
+  const onAccountsChanged = (data) => {
+    const list = Array.isArray(data) ? data : [];
+    const address = list[0];
+    if (typeof address !== "string" || !address) return setDisconnected();
+    if (!current) return;
+    current = { ...current, address };
+    emitChange();
+  };
+  const onNetworkChanged = (data) => {
+    const payload = typeof data === "object" && data !== null && !Array.isArray(data) ? data : { chainId: data };
+    const chain = toStarknetChain(payload.chainId);
+    if (!chain) return setDisconnected();
+    if (!current) return;
+    const list = Array.isArray(payload.accounts) ? payload.accounts : [];
+    const address = typeof list[0] === "string" && list[0] ? list[0] : current.address;
+    current = { address, chain };
+    emitChange();
+  };
+  transport.on("accountsChanged", onAccountsChanged);
+  transport.on("networkChanged", onNetworkChanged);
+  const request = ((call) => transport.request(call));
+  const features = {
+    "starknet:walletApi": {
+      version: "1.0.0",
+      request,
+      walletVersion: "1.0.0",
+      id: "chipi"
+    },
+    "standard:connect": {
+      version: "1.0.0",
+      connect: async (input) => {
+        if (current || input?.silent) return { accounts: accounts() };
+        await transport.open();
+        const result = await transport.request({ type: "wallet_requestAccounts" });
+        const list = Array.isArray(result) ? result : [];
+        const address = list[0];
+        if (typeof address !== "string" || !address) return { accounts: [] };
+        current = { address, chain: CHIPI_STARKNET_MAINNET_CHAIN };
+        emitChange();
+        return { accounts: accounts() };
+      }
+    },
+    "standard:disconnect": {
+      version: "1.0.0",
+      disconnect: async () => {
+        transport.close();
+        setDisconnected();
+      }
+    },
+    "standard:events": {
+      version: "1.0.0",
+      on: (_event, listener) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      }
+    }
+  };
+  return {
+    version: "1.0.0",
+    name: options.name ?? "Chipi",
+    icon: options.icon ?? CHIPI_ICON,
+    chains: [CHIPI_STARKNET_MAINNET_CHAIN],
+    get accounts() {
+      return accounts();
+    },
+    features
+  };
+}
+function registerChipiStandardWallet(options = {}, target = typeof window !== "undefined" ? window : void 0) {
+  if (!target) return () => {
+  };
+  const wallet = createChipiStandardWallet(options);
+  const unregisters = [];
+  const callback = ({ register }) => {
+    unregisters.push(register(wallet));
+  };
+  const onAppReady = (event) => {
+    const api = event.detail;
+    if (api && typeof api.register === "function") callback(api);
+  };
+  try {
+    target.dispatchEvent(
+      new CustomEvent("wallet-standard:register-wallet", {
+        detail: callback,
+        bubbles: false,
+        cancelable: false,
+        composed: false
+      })
+    );
+  } catch (error) {
+    console.error("wallet-standard:register-wallet event could not be dispatched\n", error);
+  }
+  target.addEventListener("wallet-standard:app-ready", onAppReady);
+  return () => {
+    target.removeEventListener("wallet-standard:app-ready", onAppReady);
+    for (const unregister of unregisters.splice(0)) unregister();
+  };
+}
+
+export { CHIPI_STARKNET_MAINNET_CHAIN, CHIPI_WC, CHIPI_WINDOW_KEY, ChipiConnector, ChipiPopupTransport, chipi, createChipiStandardWallet, isChipiDappMessage, isChipiWalletMessage, registerChipiStandardWallet, registerChipiWallet };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map