@gluwa/connect-kit 0.1.0-next.2 → 0.1.0-next.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @gluwa/wallet-kit
 
+## 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,399 @@
+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 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");
+    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;
+        }
+        selectedChainId = chainId;
+        config.emitter.emit("change", {
+          chainId
+        });
+        const chain = config.chains.find((c) => c.id === chainId);
+        if (!chain) throw new Error(`Chain ${chainId} not in config`);
+        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;
+        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;
+        await ensureManagerInitialized();
+        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")
+        };
+        provider = createdProvider;
+        return provider;
+      },
+      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
+};

package/dist/index.d.ts

@@ -1,8 +1,5 @@
 import { ReactNode, FC } from 'react';
-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';
+import { Config } from 'wagmi';
 
 type ConnectorId = 'CREDIT_WALLET' | 'CREDIT_CONNECT' | 'METAMASK' | 'WALLET_CONNECT';
 type CreditWalletStrategy = 'walletConnect' | 'creditConnect';
@@ -69,6 +66,16 @@ interface ConnectKitProviderProps {
      * 미제공 시 기본 동작은 selector로 복귀.
      */
     renderConnectError?: (ctx: ConnectErrorContext) => ReactNode;
+    /**
+     * 기존 프로젝트 통합용. wagmi config를 넘기면 ConnectKitProvider 내부에서
+     * WagmiProvider를 직접 세운다.
+     *
+     * - 기존 프로젝트: 앱에 WagmiProvider가 없으므로 wagmiConfig를 넘긴다.
+     *   ConnectKitProvider가 같은 config 인스턴스로 WagmiProvider를 셀프 마운트하므로
+     *   기존 wagmi 상태 store와 단일 config를 공유한다.
+     * - 신규 프로젝트: 앱이 이미 WagmiProvider를 감싸므로 이 prop은 불필요하다.
+     */
+    wagmiConfig?: Config;
 }
 interface ConnectKitContextValue {
     isOpen: boolean;
@@ -82,14 +89,4 @@ interface ConnectKitContextValue {
 declare const ConnectKitProvider: FC<ConnectKitProviderProps>;
 declare const useConnectKit: () => ConnectKitContextValue;
 
-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 ConnectErrorContext, type ConnectErrorReason, type ConnectKitContextValue, ConnectKitProvider, type ConnectKitProviderProps, ConnectModal, type ConnectModalProps, type ConnectResult, type ConnectorId, type Connectors, type CreditConnectConnectorOptions, type CreditWalletStrategy, type WCSubView, type WCWallet, creditConnectConnector, useConnectKit };
+export { type ConnectErrorContext, type ConnectErrorReason, type ConnectKitContextValue, ConnectKitProvider, type ConnectKitProviderProps, ConnectModal, type ConnectModalProps, type ConnectResult, type ConnectorId, type Connectors, type CreditWalletStrategy, type WCSubView, type WCWallet, useConnectKit };