@chipi-stack/starknet-connector 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,13 +1,588 @@
-// "Connect with Chipi" — a starknet-react / get-starknet connector for the
-// Chipi hosted smart-account wallet. No StarknetKit, no extension, no
-// WalletConnect.
-//
-//   import { chipi } from "@chipi-stack/starknet-connector";
-//   <StarknetConfig connectors={[chipi(), braavos(), argent()]}>
-//
-export { chipi } from "./factory.js";
-export { ChipiConnector } from "./connector.js";
-export { ChipiPopupTransport } from "./transport.js";
-export { registerChipiWallet, CHIPI_WINDOW_KEY } from "./register.js";
-export { CHIPI_WC, isChipiWalletMessage, isChipiDappMessage } from "./protocol.js";
+import { Connector } from '@starknet-react/core';
+import { constants, WalletAccount } from 'starknet';
+
+// src/connector.ts
+
+// src/protocol.ts
+var CHIPI_WC = "chipi-connect/v1";
+function isChipiWalletMessage(data) {
+  return typeof data === "object" && data !== null && data.channel === CHIPI_WC;
+}
+function isChipiDappMessage(data) {
+  return typeof data === "object" && data !== null && data.channel === CHIPI_WC && data.type === "rpc";
+}
+
+// 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;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function randomId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+var ChipiPopupTransport = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.target = null;
+    this.ownsTarget = false;
+    this.ready = false;
+    this.listening = false;
+    this.pending = /* @__PURE__ */ new Map();
+    this.handlers = /* @__PURE__ */ new Map();
+    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;
+      const msg = e.data;
+      if (msg.type === "ready") {
+        this.ready = true;
+        this.readyDeferred?.resolve();
+        this.readyDeferred = null;
+        for (const p of this.pending.values()) {
+          this.target.postMessage(p.message, this.walletOrigin);
+        }
+        return;
+      }
+      if (msg.type === "rpc-result") {
+        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;
+      }
+      if (msg.type === "event") {
+        this.handlers.get(msg.event)?.forEach((h) => h(msg.data));
+      }
+    };
+    this.url = opts.walletUrl.replace(/\/$/, "") + "/connect";
+    this.walletOrigin = new URL(opts.walletUrl).origin;
+  }
+  on(event, handler) {
+    (this.handlers.get(event) ?? this.handlers.set(event, /* @__PURE__ */ new Set()).get(event)).add(handler);
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+  }
+  ensureListener() {
+    if (this.listening || typeof window === "undefined") return;
+    window.addEventListener("message", this.onMessage);
+    this.listening = true;
+  }
+  /** Resolve "auto" → "parent" when iframed, else "popup". */
+  resolveMode() {
+    const mode = this.opts.mode ?? "popup";
+    if (mode !== "auto") return mode;
+    return typeof window !== "undefined" && window.parent !== window ? "parent" : "popup";
+  }
+  /** Open (or reuse) the wallet (popup window OR the parent frame) and wait for
+   * its ready handshake. Concurrent calls share ONE handshake. */
+  async open() {
+    if (typeof window === "undefined") throw new Error("chipi_connector_requires_browser");
+    this.ensureListener();
+    const isParent = this.resolveMode() === "parent";
+    if (this.ready && this.target && (isParent || !this.target.closed)) return;
+    if (this.openPromise) return this.openPromise;
+    this.openPromise = this.doOpen(isParent);
+    try {
+      await this.openPromise;
+    } finally {
+      this.openPromise = null;
+    }
+  }
+  async doOpen(isParent) {
+    if (isParent) {
+      if (window.parent === window) throw new Error("chipi_not_in_iframe");
+      this.target = window.parent;
+      this.ownsTarget = false;
+    } else {
+      this.ready = false;
+      const name = this.opts.windowName ?? `chipi-wallet-${randomId()}`;
+      this.target = window.open(
+        this.url,
+        name,
+        this.opts.windowFeatures ?? "popup=yes,width=420,height=680"
+      );
+      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();
+    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;
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error("wallet_open_timeout")), timeoutMs);
+    });
+    try {
+      await Promise.race([this.readyDeferred.promise, timeout]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  /** Reject every in-flight request (popup closed / disconnected). */
+  rejectAllPending(message) {
+    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
+   * reject them: otherwise the dApp's promise would hang forever. */
+  startCloseWatch() {
+    if (this.closeWatch || !this.ownsTarget) return;
+    this.closeWatch = setInterval(() => {
+      if (this.target?.closed) {
+        this.ready = false;
+        this.target = null;
+        this.rejectAllPending("User closed the wallet");
+        this.stopCloseWatch();
+      } else if (this.pending.size === 0) {
+        this.stopCloseWatch();
+      }
+    }, 500);
+  }
+  stopCloseWatch() {
+    if (this.closeWatch) {
+      clearInterval(this.closeWatch);
+      this.closeWatch = null;
+    }
+  }
+  /**
+   * 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();
+    const message = {
+      channel: CHIPI_WC,
+      type: "rpc",
+      id,
+      origin: window.location.origin,
+      call: stripUndefined(call)
+    };
+    const timeoutMs = this.opts.requestTimeoutMs ?? 12e4;
+    return new Promise((resolve, reject) => {
+      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();
+    });
+  }
+  /** Close the popup (if we own one) + reject in-flight requests. */
+  close() {
+    this.stopCloseWatch();
+    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);
+      this.listening = false;
+    }
+  }
+};
+
+// src/register.ts
+var CHIPI_WINDOW_KEY = "starknet_chipi";
+function registerChipiWallet(wallet, target = typeof window !== "undefined" ? window : void 0) {
+  if (!target) return { dispose: () => {
+  } };
+  const store = target;
+  store[CHIPI_WINDOW_KEY] = wallet;
+  const announce = () => target.dispatchEvent(new CustomEvent("starknet:announceWallet", { detail: wallet }));
+  target.addEventListener("starknet:requestWallets", announce);
+  announce();
+  return {
+    dispose: () => {
+      target.removeEventListener("starknet:requestWallets", announce);
+      if (store[CHIPI_WINDOW_KEY] === wallet) delete store[CHIPI_WINDOW_KEY];
+    }
+  };
+}
+
+// src/icon.ts
+var CHIPI_ICON = "data:image/png;base64,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";
+
+// src/connector.ts
+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,
+      walletUrl,
+      mode: "popup"
+      // v1: external-dApp popup only (parent host not yet built)
+    });
+    this._id = options.id ?? "chipi";
+    this._name = options.name ?? "Connect with Chipi";
+    this._icon = options.icon ?? CHIPI_ICON;
+    this._autoRegister = options.register !== false;
+    if (this._autoRegister) this.register();
+  }
+  /**
+   * Announce this wallet to scanning dApps (`window.starknet_chipi` +
+   * `starknet:announceWallet`). Called automatically from the constructor
+   * unless `register: false`. Idempotent and SSR-safe.
+   */
+  register() {
+    if (this._registration) return;
+    this._registration = registerChipiWallet(this.swo());
+  }
+  /** Undo {@link register}: remove the window object + announce listener. */
+  unregister() {
+    this._registration?.dispose();
+    this._registration = null;
+  }
+  get id() {
+    return this._id;
+  }
+  get name() {
+    return this._name;
+  }
+  get icon() {
+    return this._icon;
+  }
+  /** Hosted wallet: always available (no extension to detect). */
+  available() {
+    return true;
+  }
+  /** No silent reconnect in v1: the user re-approves the popup each session. */
+  async ready() {
+    return this._account !== null;
+  }
+  /** Lazily build the postMessage-backed get-starknet window object. */
+  swo() {
+    if (this._swo) return this._swo;
+    const transport = this.transport;
+    const request = (async (call) => transport.request(call));
+    this._swo = {
+      id: this._id,
+      name: this._name,
+      version: "1.0.0",
+      icon: typeof this._icon === "string" ? this._icon : this._icon?.dark ?? "",
+      request,
+      on: ((event, handler) => {
+        if (event === "accountsChanged" || event === "networkChanged") transport.on(event, handler);
+      }),
+      off: ((event, handler) => {
+        if (event === "accountsChanged" || event === "networkChanged")
+          transport.off(event, handler);
+      })
+    };
+    return this._swo;
+  }
+  /**
+   * 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];
+    if (!account) throw new Error("chipi_no_account");
+    this._account = account;
+    const data = { account, chainId: SN_MAIN };
+    this.emitEvent("connect", data);
+    return data;
+  }
+  async disconnect() {
+    this.unsubscribe();
+    this.transport.close();
+    this._account = null;
+    this.unregister();
+    this._swo = null;
+    this.emitEvent("disconnect");
+  }
+  /** 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) {
+    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");
+    return WalletAccount.connect(provider, this.swo());
+  }
+  async chainId() {
+    return SN_MAIN;
+  }
+  async request(call) {
+    return this.transport.request(call);
+  }
+};
+
+// src/factory.ts
+function chipi(options) {
+  return new ChipiConnector(options);
+}
+
+// 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