@gluwa/connect-kit 0.1.0-next.2 → 0.2.0-next.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @gluwa/wallet-kit
 
+## 0.2.0-next.1
+
+### Patch Changes
+
+- ee79ef9: 0.2.0
+
+## 0.1.0-next.3
+
+### Patch Changes
+
+- fa6fa6f: 0.1.0-next.3
+
 ## 0.1.0-next.2
 
 ### Patch Changes

package/dist/chunk-DDA6FP6U.js

@@ -0,0 +1,7 @@
+import React from "react";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+export {
+  __name
+};

package/dist/credit-connect.d.ts

@@ -0,0 +1,16 @@
+import { createConnector } from '@wagmi/core';
+import { StorageProvider } from '@gluwa/credit-connect-sdk/storage';
+import { E2EEProvider } from '@gluwa/credit-connect-sdk/e2ee';
+import { HubFactoryProvider } from '@gluwa/credit-connect-sdk/hub';
+
+type CreditConnectConnectorOptions = {
+    projectKey: string;
+    serverUrl: string;
+    storage: StorageProvider;
+    e2ee: E2EEProvider;
+    createHub: HubFactoryProvider['createHubFromDapp'];
+    onDisplayUri?: (uri: string | null) => void;
+};
+declare const creditConnectConnector: (options: CreditConnectConnectorOptions) => ReturnType<typeof createConnector>;
+
+export { type CreditConnectConnectorOptions, creditConnectConnector };

package/dist/credit-connect.js

@@ -0,0 +1,414 @@
+import React from "react";
+import {
+  __name
+} from "./chunk-DDA6FP6U.js";
+
+// src/creditConnectConnector.ts
+import { createConnector } from "@wagmi/core";
+import { getAddress } from "viem";
+import { DappSessionManager } from "@gluwa/credit-connect-sdk/dapp";
+var CONNECTOR_ID = "credit-connect";
+var CONNECTOR_NAME = "Credit Wallet";
+var CONNECTOR_TYPE = "credit-connect";
+var castConnectResult = /* @__PURE__ */ __name((value) => value, "castConnectResult");
+var creditConnectConnector = /* @__PURE__ */ __name((options) => {
+  let manager = null;
+  let selectedChainId = null;
+  let connectPromise = null;
+  let provider = null;
+  let providerPromise = null;
+  let isLocalDisconnect = false;
+  let emitWagmiMessage = null;
+  let emitWagmiDisconnect = null;
+  const providerListeners = /* @__PURE__ */ new Map();
+  const emitProviderEvent = /* @__PURE__ */ __name((event, ...args) => {
+    const listeners = providerListeners.get(event);
+    if (listeners) for (const fn of listeners) fn(...args);
+  }, "emitProviderEvent");
+  const getCurrentSession = /* @__PURE__ */ __name(() => {
+    if (!manager || manager.state.status !== "CONNECTED" || !manager.state.session) return null;
+    return manager.state.session;
+  }, "getCurrentSession");
+  const getEvmAddressInfo = /* @__PURE__ */ __name((session) => session.addressInfoList.filter((info) => info.networkType === "eip155"), "getEvmAddressInfo");
+  const getChecksummedAccounts = /* @__PURE__ */ __name((session) => getEvmAddressInfo(session).map((info) => getAddress(info.address)), "getChecksummedAccounts");
+  const resetState = /* @__PURE__ */ __name(() => {
+    connectPromise = null;
+    selectedChainId = null;
+  }, "resetState");
+  const createManagerIfNeeded = /* @__PURE__ */ __name(() => {
+    if (manager) return manager;
+    manager = new DappSessionManager({
+      projectKey: options.projectKey,
+      serverUrl: options.serverUrl,
+      storage: options.storage,
+      e2ee: options.e2ee,
+      createHub: options.createHub,
+      enableReconnect: true,
+      autoInit: true
+    });
+    manager.on("changeState", (state) => {
+      var _a;
+      if (state.status === "CONNECTING" && state.connectingPayload) {
+        (_a = options.onDisplayUri) == null ? void 0 : _a.call(options, state.connectingPayload);
+        emitWagmiMessage == null ? void 0 : emitWagmiMessage("display_uri", state.connectingPayload);
+      }
+      if (state.status === "DISCONNECTED" && !isLocalDisconnect) {
+        resetState();
+        emitProviderEvent("disconnect");
+        emitWagmiDisconnect == null ? void 0 : emitWagmiDisconnect();
+      }
+    });
+    return manager;
+  }, "createManagerIfNeeded");
+  const ensureManagerInitialized = /* @__PURE__ */ __name(async () => {
+    const m = createManagerIfNeeded();
+    if (m.state.status === "PENDING") {
+      await m.initSession();
+      return m;
+    }
+    if (m.state.status === "INITIALIZING") {
+      await new Promise((resolve) => {
+        const unsub = m.on("changeState", (state) => {
+          if (state.status !== "INITIALIZING") {
+            unsub();
+            resolve();
+          }
+        });
+      });
+    }
+    return m;
+  }, "ensureManagerInitialized");
+  return createConnector((config) => {
+    emitWagmiMessage = /* @__PURE__ */ __name((type, data) => {
+      config.emitter.emit("message", {
+        type,
+        data
+      });
+    }, "emitWagmiMessage");
+    emitWagmiDisconnect = /* @__PURE__ */ __name(() => {
+      config.emitter.emit("disconnect");
+    }, "emitWagmiDisconnect");
+    const buildProvider = /* @__PURE__ */ __name(() => {
+      const createdProvider = {
+        request: /* @__PURE__ */ __name(async (args) => {
+          const { method, params: rawParams } = args;
+          const params = Array.isArray(rawParams) ? [
+            ...rawParams
+          ] : rawParams === void 0 ? [] : [
+            rawParams
+          ];
+          const session = getCurrentSession();
+          const getSelectedAddressInfo = /* @__PURE__ */ __name((address) => {
+            if (!session) throw new Error("No active session");
+            const evmInfo = getEvmAddressInfo(session);
+            if (evmInfo.length === 0) throw new Error("No EVM address found");
+            if (!address) return evmInfo[0];
+            const found = evmInfo.find((info) => info.address.toLowerCase() === address.toLowerCase());
+            if (!found) throw new Error(`Address not in session: ${address}`);
+            return found;
+          }, "getSelectedAddressInfo");
+          if (method === "eth_accounts") {
+            if (!session) return [];
+            return getChecksummedAccounts(session);
+          }
+          if (method === "eth_chainId") {
+            if (!session) throw new Error("No active session");
+            if (selectedChainId !== null) return `0x${selectedChainId.toString(16)}`;
+            const evmInfo = getEvmAddressInfo(session);
+            if (evmInfo.length === 0) throw new Error("No EVM address found");
+            const chainId = Number.parseInt(evmInfo[0].networkIdentifier, 10);
+            if (!Number.isFinite(chainId)) throw new Error(`Invalid chainId: ${chainId}`);
+            selectedChainId = chainId;
+            return `0x${chainId.toString(16)}`;
+          }
+          if (method === "wallet_switchEthereumChain") {
+            const [{ chainId: rawChainId }] = params != null ? params : [];
+            if (!rawChainId) throw new Error("wallet_switchEthereumChain missing chainId param");
+            const chainId = Number.parseInt(rawChainId, 16);
+            if (!Number.isFinite(chainId)) throw new Error(`Invalid chainId: ${rawChainId}`);
+            if (!session) throw new Error("No active session");
+            const supported = getEvmAddressInfo(session).some((info) => Number.parseInt(info.networkIdentifier, 10) === chainId);
+            if (!supported) {
+              const err = new Error(`Unsupported chain: ${chainId}`);
+              err.code = 4902;
+              throw err;
+            }
+            selectedChainId = chainId;
+            config.emitter.emit("change", {
+              chainId
+            });
+            return null;
+          }
+          if (method === "personal_sign") {
+            const [messageParam, addressParam] = params != null ? params : [];
+            const message = typeof messageParam === "string" ? messageParam : String(messageParam != null ? messageParam : "");
+            const address = typeof addressParam === "string" ? addressParam : void 0;
+            const addressInfo = getSelectedAddressInfo(address);
+            const response = await (session == null ? void 0 : session.jsonRpc.request("signMessage", {
+              message,
+              addressInfo
+            }));
+            return response == null ? void 0 : response.signature;
+          }
+          if (method === "eth_sign") {
+            const [addressParam, messageParam] = params != null ? params : [];
+            const address = typeof addressParam === "string" ? addressParam : void 0;
+            const message = typeof messageParam === "string" ? messageParam : String(messageParam != null ? messageParam : "");
+            const addressInfo = getSelectedAddressInfo(address);
+            const response = await (session == null ? void 0 : session.jsonRpc.request("signMessage", {
+              message,
+              addressInfo
+            }));
+            return response == null ? void 0 : response.signature;
+          }
+          if (method === "eth_signTypedData" || method === "eth_signTypedData_v4") {
+            const [addressParam, typedDataParam] = params != null ? params : [];
+            const address = typeof addressParam === "string" ? addressParam : void 0;
+            const typedData = typeof typedDataParam === "string" ? typedDataParam : JSON.stringify(typedDataParam != null ? typedDataParam : "");
+            const addressInfo = getSelectedAddressInfo(address);
+            const response = await (session == null ? void 0 : session.jsonRpc.request("signTypedData", {
+              typedData,
+              addressInfo
+            }));
+            return response == null ? void 0 : response.signature;
+          }
+          if (method === "eth_sendTransaction") {
+            const [txParams] = params != null ? params : [];
+            const addressInfo = getSelectedAddressInfo(txParams == null ? void 0 : txParams.from);
+            const response = await (session == null ? void 0 : session.jsonRpc.request("sendTransaction", {
+              addressInfo,
+              to: txParams == null ? void 0 : txParams.to,
+              value: txParams == null ? void 0 : txParams.value,
+              data: txParams == null ? void 0 : txParams.data,
+              gas: txParams == null ? void 0 : txParams.gas,
+              gasPrice: txParams == null ? void 0 : txParams.gasPrice,
+              maxFeePerGas: txParams == null ? void 0 : txParams.maxFeePerGas,
+              maxPriorityFeePerGas: txParams == null ? void 0 : txParams.maxPriorityFeePerGas,
+              nonce: txParams == null ? void 0 : txParams.nonce,
+              chainId: txParams == null ? void 0 : txParams.chainId
+            }));
+            return response == null ? void 0 : response.txHash;
+          }
+          if (method === "credit_connect_send_message") {
+            if (!session) throw new Error("No active session");
+            const [messageParam] = params != null ? params : [];
+            const message = typeof messageParam === "string" ? messageParam : JSON.stringify(messageParam != null ? messageParam : "");
+            await session.msg.sendMessage(message);
+            return true;
+          }
+          if (method === "credit_connect_jsonrpc_ping") {
+            if (!session) throw new Error("No active session");
+            return await session.jsonRpc.request("pingPong", {});
+          }
+          throw new Error(`Unsupported provider method: ${method}`);
+        }, "request"),
+        on: /* @__PURE__ */ __name((event, listener) => {
+          let listeners = providerListeners.get(event);
+          if (!listeners) {
+            listeners = /* @__PURE__ */ new Set();
+            providerListeners.set(event, listeners);
+          }
+          listeners.add(listener);
+          return createdProvider;
+        }, "on"),
+        removeListener: /* @__PURE__ */ __name((event, listener) => {
+          var _a;
+          (_a = providerListeners.get(event)) == null ? void 0 : _a.delete(listener);
+          return createdProvider;
+        }, "removeListener")
+      };
+      return createdProvider;
+    }, "buildProvider");
+    return {
+      id: CONNECTOR_ID,
+      name: CONNECTOR_NAME,
+      type: CONNECTOR_TYPE,
+      async setup() {
+        await ensureManagerInitialized();
+      },
+      async connect(parameters) {
+        var _a;
+        try {
+          const m = createManagerIfNeeded();
+          if (m.state.status === "INITIALIZING") {
+            await new Promise((resolve) => {
+              const unsub = m.on("changeState", (state) => {
+                if (state.status !== "INITIALIZING") {
+                  unsub();
+                  resolve();
+                }
+              });
+            });
+          }
+          if (parameters == null ? void 0 : parameters.isReconnecting) {
+            const session2 = getCurrentSession();
+            if (!session2) throw new Error("No active session to reconnect");
+            const accounts2 = getChecksummedAccounts(session2);
+            if (accounts2.length === 0) throw new Error("No EVM address found");
+            const chainId2 = Number.parseInt(getEvmAddressInfo(session2)[0].networkIdentifier, 10);
+            if (!Number.isFinite(chainId2)) throw new Error(`Invalid chainId: ${chainId2}`);
+            selectedChainId = chainId2;
+            if ((parameters == null ? void 0 : parameters.withCapabilities) === true) {
+              return castConnectResult({
+                accounts: accounts2.map((address) => ({
+                  address,
+                  capabilities: {}
+                })),
+                chainId: chainId2
+              });
+            }
+            return castConnectResult({
+              accounts: accounts2,
+              chainId: chainId2
+            });
+          }
+          if (m.state.status === "CONNECTING" && m.state.connectingPayload) {
+            (_a = options.onDisplayUri) == null ? void 0 : _a.call(options, m.state.connectingPayload);
+            if (!connectPromise) {
+              connectPromise = new Promise((resolve) => {
+                const unsub = m.on("changeState", (state) => {
+                  if (state.status === "CONNECTED") {
+                    unsub();
+                    resolve(true);
+                  } else if (state.status === "DISCONNECTED") {
+                    unsub();
+                    resolve(false);
+                  }
+                });
+              });
+            }
+          }
+          if (m.state.status !== "CONNECTED") {
+            if (!connectPromise) {
+              if (m.state.status !== "DISCONNECTED") {
+                throw new Error(`Cannot connect from ${m.state.status} state`);
+              }
+              connectPromise = m.connectNewSession();
+            }
+            const connected = await connectPromise;
+            connectPromise = null;
+            if (!connected) throw new Error("Credit Connect session failed");
+          }
+          const session = getCurrentSession();
+          if (!session) throw new Error("Credit Connect session failed");
+          const accounts = getChecksummedAccounts(session);
+          if (accounts.length === 0) throw new Error("No EVM address found");
+          const chainId = Number.parseInt(getEvmAddressInfo(session)[0].networkIdentifier, 10);
+          if (!Number.isFinite(chainId)) throw new Error(`Invalid chainId: ${chainId}`);
+          selectedChainId = chainId;
+          if ((parameters == null ? void 0 : parameters.withCapabilities) === true) {
+            return castConnectResult({
+              accounts: accounts.map((address) => ({
+                address,
+                capabilities: {}
+              })),
+              chainId
+            });
+          }
+          return castConnectResult({
+            accounts,
+            chainId
+          });
+        } catch (error) {
+          resetState();
+          throw error;
+        }
+      },
+      async switchChain({ chainId }) {
+        const session = getCurrentSession();
+        if (!session) throw new Error("No active session");
+        const supported = getEvmAddressInfo(session).some((info) => Number.parseInt(info.networkIdentifier, 10) === chainId);
+        if (!supported) {
+          const err = new Error(`Unsupported chain: ${chainId}`);
+          err.code = 4902;
+          throw err;
+        }
+        const chain = config.chains.find((c) => c.id === chainId);
+        if (!chain) throw new Error(`Chain ${chainId} not in config`);
+        selectedChainId = chainId;
+        config.emitter.emit("change", {
+          chainId
+        });
+        await Promise.resolve();
+        return chain;
+      },
+      async isAuthorized() {
+        await ensureManagerInitialized();
+        const session = getCurrentSession();
+        if (!session) return false;
+        return session.addressInfoList.some((info) => info.networkType === "eip155");
+      },
+      async disconnect() {
+        isLocalDisconnect = true;
+        try {
+          if ((manager == null ? void 0 : manager.state.status) === "CONNECTED") {
+            await manager.disconnectSession();
+          }
+        } finally {
+          isLocalDisconnect = false;
+        }
+        provider = null;
+        providerPromise = null;
+        resetState();
+        config.emitter.emit("disconnect");
+      },
+      async getAccounts() {
+        await ensureManagerInitialized();
+        const session = getCurrentSession();
+        if (!session) return [];
+        return getChecksummedAccounts(session);
+      },
+      async getChainId() {
+        await ensureManagerInitialized();
+        const session = getCurrentSession();
+        if (!session) throw new Error("No active session");
+        if (selectedChainId !== null) return selectedChainId;
+        const evmAddressInfo = getEvmAddressInfo(session);
+        if (evmAddressInfo.length === 0) throw new Error("No EVM address found");
+        const chainId = Number.parseInt(evmAddressInfo[0].networkIdentifier, 10);
+        if (!Number.isFinite(chainId)) throw new Error(`Invalid chainId: ${chainId}`);
+        selectedChainId = chainId;
+        return chainId;
+      },
+      async getProvider() {
+        if (provider) return provider;
+        if (providerPromise) return providerPromise;
+        providerPromise = (async () => {
+          await ensureManagerInitialized();
+          const createdProvider = buildProvider();
+          provider = createdProvider;
+          return createdProvider;
+        })();
+        try {
+          return await providerPromise;
+        } finally {
+          providerPromise = null;
+        }
+      },
+      onAccountsChanged(accounts) {
+        if (!accounts || accounts.length === 0) {
+          config.emitter.emit("disconnect");
+          return;
+        }
+        config.emitter.emit("change", {
+          accounts: accounts.map(getAddress)
+        });
+      },
+      onChainChanged(chainId) {
+        const normalized = typeof chainId === "string" ? Number.parseInt(chainId, 16) : Number(chainId);
+        if (!Number.isFinite(normalized)) return;
+        selectedChainId = normalized;
+        config.emitter.emit("change", {
+          chainId: normalized
+        });
+      },
+      onDisconnect() {
+        resetState();
+        config.emitter.emit("disconnect");
+      }
+    };
+  });
+}, "creditConnectConnector");
+export {
+  creditConnectConnector
+};