@d10r/wagmi-superfluid-wallet 0.1.0-rc.0

package/README.md

@@ -0,0 +1,52 @@
+# @d10r/wagmi-superfluid-wallet
+
+> Release candidate (`0.1.0-rc.0`). Install with `pnpm add @d10r/wagmi-superfluid-wallet@rc`.
+
+wagmi v2 connector for [Superfluid Wallet](https://wallet.superfluid.org) — a hosted popup for auth and signing.
+
+Your dapp keeps using normal wagmi hooks. The connector opens the wallet popup for signing, syncs chain ID on connect/switch, and uses your wagmi `transports` for everything else (reads, gas estimation, broadcast).
+
+## Setup
+
+```bash
+pnpm add @d10r/wagmi-superfluid-wallet@rc wagmi viem
+```
+
+```typescript
+import { createConfig, http } from 'wagmi'
+import { superfluidWallet } from '@d10r/wagmi-superfluid-wallet'
+
+const sfWallet = superfluidWallet() // defaults to https://wallet.superfluid.org
+
+export const config = createConfig({
+  chains,
+  transports: { /* http / fallback per chain */ },
+  connectors: [
+    sfWallet.connector(),
+    // ...injected, walletConnect, etc.
+  ],
+})
+```
+
+Local wallet: `superfluidWallet({ walletUrl: 'http://localhost:3001' })`
+
+Env-gated registration is a one-liner in your wagmi config — no package helper needed.
+
+## Before going live
+
+1. Configure `chains` + `transports` in wagmi (RPC reliability lives here).
+2. Add your dapp origin to the hosted wallet's `NEXT_PUBLIC_ALLOWED_DAPP_ORIGINS`.
+3. Add the **wallet** origin (not the dapp) to Turnkey Auth Proxy allowed origins.
+
+## Testing without Turnkey
+
+Set `window.__SUPERFLUID_WALLET_MOCK_HANDLER__` before connecting. The provider skips the popup when present. See `src/eip1193-provider.test.ts`.
+
+## Options
+
+| Field | Default |
+|-------|---------|
+| `walletUrl` | `https://wallet.superfluid.org` |
+| `connectorId` | `superfluidWallet` |
+| `storageKey` | `SF:EIP1193Provider:store` |
+| `popupTimeoutMs` | `300000` |

package/dist/index.cjs

@@ -0,0 +1,543 @@
+'use strict';
+
+var core = require('@wagmi/core');
+var viem = require('viem');
+var wagmi = require('wagmi');
+var actions = require('viem/actions');
+var utils = require('viem/utils');
+
+// src/config.ts
+var DEFAULT_WALLET_URL = "https://wallet.superfluid.org";
+var DEFAULT_CONNECTOR_ID = "superfluidWallet";
+var DEFAULT_STORAGE_KEY = "SF:EIP1193Provider:store";
+var DEFAULT_POPUP_TIMEOUT_MS = 3e5;
+function resolveSuperfluidWalletConfig(config = {}) {
+  const walletUrl = (config.walletUrl ?? DEFAULT_WALLET_URL).trim().replace(/\/$/, "");
+  let walletOrigin;
+  try {
+    walletOrigin = new URL(walletUrl).origin;
+  } catch {
+    throw new Error(`Invalid walletUrl: ${config.walletUrl ?? walletUrl}`);
+  }
+  return {
+    walletUrl,
+    walletOrigin,
+    connectorId: config.connectorId ?? DEFAULT_CONNECTOR_ID,
+    storageKey: config.storageKey ?? DEFAULT_STORAGE_KEY,
+    popupTimeoutMs: config.popupTimeoutMs ?? DEFAULT_POPUP_TIMEOUT_MS
+  };
+}
+
+// src/event-emitter.ts
+var EventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event)?.add(listener);
+  }
+  emit(event, ...args) {
+    for (const listener of this.listeners.get(event) ?? []) {
+      listener(...args);
+    }
+  }
+  removeListener(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+};
+
+// src/provider-store.ts
+function createProviderStore(storageKey) {
+  const eventEmitter = new EventEmitter();
+  const getState = () => {
+    if (typeof localStorage === "undefined") {
+      return { accounts: [], organizationId: void 0, chainId: void 0 };
+    }
+    const stored = localStorage.getItem(storageKey);
+    return stored ? JSON.parse(stored) : { accounts: [], organizationId: void 0, chainId: void 0 };
+  };
+  const update = (updates) => {
+    const current = getState();
+    const next = { ...current, ...updates };
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(storageKey, JSON.stringify(next));
+    }
+    if (updates.accounts && JSON.stringify(updates.accounts) !== JSON.stringify(current.accounts)) {
+      eventEmitter.emit("accountsChanged", updates.accounts);
+    }
+    if (updates.chainId !== void 0 && updates.chainId !== current.chainId) {
+      eventEmitter.emit("chainChanged", `0x${updates.chainId.toString(16)}`);
+    }
+  };
+  return {
+    storageKey,
+    getState,
+    setChainId: (chainId) => update({ chainId }),
+    update,
+    clear: () => {
+      if (typeof localStorage !== "undefined") {
+        localStorage.removeItem(storageKey);
+      }
+    },
+    onAccountsChanged: (listener) => {
+      eventEmitter.on("accountsChanged", listener);
+    },
+    onChainChanged: (listener) => {
+      eventEmitter.on("chainChanged", listener);
+    }
+  };
+}
+function getStoredChainIdHex(store) {
+  const { chainId } = store.getState();
+  if (chainId === void 0) return void 0;
+  return `0x${chainId.toString(16)}`;
+}
+
+// src/enrichPopupRequest.ts
+function enrichSignTransactionParams(params, chainIdHex) {
+  const txParams = params;
+  const transaction = txParams?.[0];
+  if (!transaction) return params;
+  if (transaction.chainId !== void 0 && transaction.chainId !== null) {
+    return params;
+  }
+  if (!chainIdHex) {
+    throw new Error("No chain ID available. Select a network and retry.");
+  }
+  return [{ ...transaction, chainId: chainIdHex }];
+}
+function enrichPopupParams(method, params, chainIdHex) {
+  if (method === "eth_signTransaction") {
+    return enrichSignTransactionParams(params, chainIdHex);
+  }
+  return params;
+}
+function toOptionalBigInt(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "number") return BigInt(value);
+  if (typeof value === "string" && value.startsWith("0x")) {
+    return viem.hexToBigInt(value);
+  }
+  throw new Error(`Invalid ${field}: expected hex or number`);
+}
+function resolveChainIdFromTransaction(transaction, fallbackChainId) {
+  const parsed = toOptionalBigInt(transaction.chainId, "chainId");
+  if (parsed !== void 0) return Number(parsed);
+  if (fallbackChainId !== void 0) return fallbackChainId;
+  throw new Error("No chain ID available. Select a network and retry.");
+}
+async function prepareSignTransactionParams(params, options) {
+  const txParams = params;
+  const transaction = txParams?.[0];
+  if (!transaction) {
+    throw new Error("Missing transaction for eth_signTransaction");
+  }
+  if (!transaction.from) {
+    throw new Error("Transaction is missing from");
+  }
+  if (!transaction.to) {
+    throw new Error("Transaction is missing to");
+  }
+  const chainId = resolveChainIdFromTransaction(transaction, options.fallbackChainId);
+  const prepare = options.prepareRequest ?? actions.prepareTransactionRequest;
+  const prepareRequest = {
+    account: transaction.from,
+    to: transaction.to,
+    data: transaction.data,
+    value: toOptionalBigInt(transaction.value, "value"),
+    gas: toOptionalBigInt(transaction.gas ?? transaction.gasLimit, "gas"),
+    maxFeePerGas: toOptionalBigInt(transaction.maxFeePerGas, "maxFeePerGas"),
+    maxPriorityFeePerGas: toOptionalBigInt(
+      transaction.maxPriorityFeePerGas,
+      "maxPriorityFeePerGas"
+    ),
+    nonce: toOptionalBigInt(transaction.nonce, "nonce") !== void 0 ? Number(toOptionalBigInt(transaction.nonce, "nonce")) : void 0,
+    chainId,
+    type: "eip1559"
+  };
+  const prepared = await prepare(
+    options.client,
+    // @ts-expect-error viem PrepareTransactionRequestParameters mismatch for dynamic RPC clients
+    prepareRequest
+  );
+  if (prepared.gas === void 0 || prepared.maxFeePerGas === void 0 || prepared.maxPriorityFeePerGas === void 0 || prepared.nonce === void 0) {
+    throw new Error("Failed to prepare a complete EIP-1559 transaction");
+  }
+  const rpcTx = {
+    from: transaction.from,
+    to: prepared.to,
+    gas: utils.numberToHex(prepared.gas),
+    maxFeePerGas: utils.numberToHex(prepared.maxFeePerGas),
+    maxPriorityFeePerGas: utils.numberToHex(prepared.maxPriorityFeePerGas),
+    nonce: utils.numberToHex(BigInt(prepared.nonce)),
+    value: prepared.value !== void 0 ? utils.numberToHex(prepared.value) : "0x0",
+    chainId: utils.numberToHex(BigInt(chainId))
+  };
+  if (prepared.data) {
+    rpcTx.data = prepared.data;
+  }
+  return [rpcTx];
+}
+
+// src/resolvePopupParams.ts
+async function resolvePopupParams(method, params, chainIdHex, getClient) {
+  if (method !== "eth_signTransaction") {
+    return enrichPopupParams(method, params, chainIdHex);
+  }
+  const fallbackChainId = chainIdHex ? Number.parseInt(chainIdHex, 16) : void 0;
+  if (fallbackChainId === void 0 || Number.isNaN(fallbackChainId)) {
+    throw new Error("No chain ID available. Select a network and retry.");
+  }
+  const client = getClient({ chainId: fallbackChainId });
+  return prepareSignTransactionParams(params, {
+    fallbackChainId,
+    client
+  });
+}
+
+// src/eip1193-provider.ts
+var POPUP_METHODS = /* @__PURE__ */ new Set([
+  "eth_requestAccounts",
+  "eth_signTransaction",
+  "eth_sign",
+  "personal_sign"
+]);
+var PUBLIC_RPC_METHODS = /* @__PURE__ */ new Set([
+  "eth_sendRawTransaction",
+  "eth_subscribe",
+  "eth_unsubscribe",
+  "eth_blobBaseFee",
+  "eth_blockNumber",
+  "eth_call",
+  "eth_coinbase",
+  "eth_estimateGas",
+  "eth_feeHistory",
+  "eth_gasPrice",
+  "eth_getBalance",
+  "eth_getBlockByHash",
+  "eth_getBlockByNumber",
+  "eth_getBlockReceipts",
+  "eth_getBlockTransactionCountByHash",
+  "eth_getBlockTransactionCountByNumber",
+  "eth_getCode",
+  "eth_getFilterChanges",
+  "eth_getFilterLogs",
+  "eth_getLogs",
+  "eth_getProof",
+  "eth_getStorageAt",
+  "eth_getTransactionByBlockHashAndIndex",
+  "eth_getTransactionByBlockNumberAndIndex",
+  "eth_getTransactionByHash",
+  "eth_getTransactionCount",
+  "eth_getTransactionReceipt",
+  "eth_getUncleCountByBlockHash",
+  "eth_getUncleCountByBlockNumber",
+  "eth_maxPriorityFeePerGas",
+  "eth_newBlockFilter",
+  "eth_newFilter",
+  "eth_newPendingTransactionFilter",
+  "eth_syncing",
+  "eth_uninstallFilter"
+]);
+function requireStoredChainId(store, context) {
+  const { chainId } = store.getState();
+  if (chainId === void 0) {
+    throw new Error(context);
+  }
+  return chainId;
+}
+function createEIP1193Provider(config, store, getClient) {
+  let popup = null;
+  const eventEmitter = new EventEmitter();
+  store.onAccountsChanged((accounts) => {
+    eventEmitter.emit("accountsChanged", accounts);
+  });
+  store.onChainChanged((chain) => {
+    eventEmitter.emit("chainChanged", chain);
+  });
+  const requestQueue = {};
+  const handleMessage = (event) => {
+    if (event.origin !== config.walletOrigin || event.source !== popup) return;
+    const { method, result, error } = event.data;
+    if (method && requestQueue[method]) {
+      if (error) {
+        requestQueue[method].reject({
+          code: error.code,
+          message: error.message,
+          data: error.data
+        });
+      } else {
+        if (method === "eth_requestAccounts") {
+          const { accounts, organizationId } = result[0];
+          store.update({ accounts, organizationId });
+          requestQueue[method].resolve(accounts);
+        } else {
+          requestQueue[method].resolve(result);
+        }
+      }
+      delete requestQueue[method];
+    }
+  };
+  if (typeof window !== "undefined") {
+    window.addEventListener("message", handleMessage);
+  }
+  const requestImpl = async (args) => {
+    const { method, params } = args;
+    if (typeof window === "undefined") {
+      throw new Error("Window is not defined");
+    }
+    if (method === "eth_sendTransaction") {
+      const [transaction] = params;
+      const signedTransaction = await requestImpl({
+        method: "eth_signTransaction",
+        params: [transaction]
+      });
+      return requestImpl({
+        method: "eth_sendRawTransaction",
+        params: [signedTransaction]
+      });
+    }
+    if (method === "eth_accounts") {
+      return store.getState().accounts;
+    }
+    if (method === "eth_chainId") {
+      const chainId = requireStoredChainId(
+        store,
+        "No chain ID available. Connect a wallet and select a network first."
+      );
+      return `0x${chainId.toString(16)}`;
+    }
+    if (PUBLIC_RPC_METHODS.has(method)) {
+      const chainId = requireStoredChainId(
+        store,
+        "No chain ID available for RPC request. Select a network and retry."
+      );
+      const client = getClient({ chainId });
+      return await client.request({
+        method,
+        params
+      });
+    }
+    if (POPUP_METHODS.has(method)) {
+      const mockHandler = window.__SUPERFLUID_WALLET_MOCK_HANDLER__;
+      if (mockHandler) {
+        const popupParams = await resolvePopupParams(
+          method,
+          params,
+          getStoredChainIdHex(store),
+          getClient
+        );
+        const result = await Promise.resolve(mockHandler(method, popupParams));
+        if (method === "eth_requestAccounts") {
+          const { accounts, organizationId } = result[0];
+          store.update({ accounts, organizationId });
+          return accounts;
+        }
+        return result;
+      }
+      if (popup && !popup.closed) {
+        popup.close();
+        popup = null;
+      }
+    }
+    if (!popup || popup.closed) {
+      const width = 360;
+      const height = 600;
+      const left = window.screenX + (window.outerWidth - width) / 2;
+      const top = window.screenY + (window.outerHeight - height) / 2;
+      const { organizationId } = store.getState();
+      const orgParam = organizationId ? `&organizationId=${organizationId}` : "";
+      const chainIdHex = getStoredChainIdHex(store);
+      const chainParam = chainIdHex ? `&chainId=${encodeURIComponent(chainIdHex)}` : "";
+      const popupParams = await resolvePopupParams(method, params, chainIdHex, getClient);
+      const dappOriginParam = `&dappOrigin=${encodeURIComponent(window.location.origin)}`;
+      popup = window.open(
+        `${config.walletUrl}?request=${encodeURIComponent(JSON.stringify({ method, params: popupParams }))}${orgParam}${chainParam}${dappOriginParam}`,
+        "Superfluid Wallet",
+        `width=${width},height=${height},left=${left},top=${top}`
+      );
+      if (!popup) {
+        throw new Error("Popup blocked. Allow popups for this site and try again.");
+      }
+    }
+    return new Promise((resolve, reject) => {
+      requestQueue[method] = { resolve, reject };
+      setTimeout(() => {
+        if (requestQueue[method]) {
+          delete requestQueue[method];
+          if (popup?.closed) {
+            reject(new Error("Wallet popup was closed before the request completed."));
+          } else {
+            reject(new Error("Wallet request timed out."));
+          }
+        }
+      }, config.popupTimeoutMs);
+    });
+  };
+  return {
+    request: requestImpl,
+    on: eventEmitter.on.bind(eventEmitter),
+    removeListener: eventEmitter.removeListener.bind(eventEmitter)
+  };
+}
+function createWagmiGetClient(wagmiConfig) {
+  return (parameters) => {
+    const chainId = parameters?.chainId;
+    if (chainId === void 0) {
+      throw new Error("chainId is required to resolve a wagmi client");
+    }
+    return getClientForChain(wagmiConfig, chainId, "wagmi client lookup failed");
+  };
+}
+function getClientForChain(wagmiConfig, chainId, context) {
+  const transport = wagmiConfig.transports?.[chainId];
+  if (!transport) {
+    throw new Error(
+      `${context}: no wagmi transport for chain ${chainId}. Configure transports in createConfig.`
+    );
+  }
+  const chain = wagmiConfig.chains.find((c) => c.id === chainId);
+  if (!chain) {
+    throw new Error(
+      `${context}: chain ${chainId} is not configured in wagmi. Add it to createConfig({ chains }).`
+    );
+  }
+  return viem.createClient({ chain, transport });
+}
+
+// src/connector.ts
+function createSuperfluidWalletConnector(config, store) {
+  return wagmi.createConnector((wagmiConfig) => {
+    let provider = null;
+    let accountsChanged;
+    let chainChanged;
+    let disconnect;
+    const getProvider = () => {
+      if (!provider) {
+        provider = createEIP1193Provider(config, store, createWagmiGetClient(wagmiConfig));
+      }
+      return provider;
+    };
+    return {
+      id: config.connectorId,
+      name: "Superfluid Wallet",
+      type: "superfluidWallet",
+      async connect(_params) {
+        const initialChainId = _params?.chainId ?? wagmiConfig.chains[0]?.id;
+        if (initialChainId) {
+          store.setChainId(initialChainId);
+        }
+        const p = await this.getProvider();
+        let accounts = _params?.isReconnecting ? await p.request({ method: "eth_accounts" }) : [];
+        if (!accounts.length) {
+          accounts = await p.request({ method: "eth_requestAccounts" });
+        }
+        if (!accountsChanged) {
+          accountsChanged = this.onAccountsChanged.bind(this);
+          p.on("accountsChanged", accountsChanged);
+        }
+        if (!chainChanged) {
+          chainChanged = this.onChainChanged.bind(this);
+          p.on("chainChanged", chainChanged);
+        }
+        if (!disconnect) {
+          disconnect = this.onDisconnect.bind(this);
+          p.on("disconnect", disconnect);
+        }
+        const chainId = Number(await p.request({ method: "eth_chainId" }));
+        return { accounts, chainId };
+      },
+      async getProvider() {
+        return getProvider();
+      },
+      async disconnect() {
+        const p = await this.getProvider();
+        if (accountsChanged) {
+          p.removeListener("accountsChanged", accountsChanged);
+          accountsChanged = void 0;
+        }
+        if (chainChanged) {
+          p.removeListener("chainChanged", chainChanged);
+          chainChanged = void 0;
+        }
+        if (disconnect) {
+          p.removeListener("disconnect", disconnect);
+          disconnect = void 0;
+        }
+        store.clear();
+      },
+      async getAccounts() {
+        const p = await this.getProvider();
+        return await p.request({ method: "eth_accounts" });
+      },
+      async getChainId() {
+        const p = await this.getProvider();
+        return Number(await p.request({ method: "eth_chainId" }));
+      },
+      async switchChain({ chainId }) {
+        const chain = wagmiConfig.chains.find((x) => x.id === chainId);
+        if (!chain) {
+          throw new viem.SwitchChainError(new core.ChainNotConfiguredError());
+        }
+        store.setChainId(chainId);
+        return chain;
+      },
+      async isAuthorized() {
+        try {
+          return (await this.getAccounts()).length > 0;
+        } catch {
+          return false;
+        }
+      },
+      onAccountsChanged(accounts) {
+        if (accounts.length === 0) this.onDisconnect();
+        else {
+          wagmiConfig.emitter.emit("change", {
+            accounts: accounts.map((x) => viem.getAddress(x))
+          });
+        }
+      },
+      onChainChanged(chain) {
+        const chainId = Number(chain);
+        store.setChainId(chainId);
+        wagmiConfig.emitter.emit("change", { chainId });
+      },
+      async onDisconnect() {
+        wagmiConfig.emitter.emit("disconnect");
+        store.clear();
+        const p = await this.getProvider();
+        if (accountsChanged) {
+          p.removeListener("accountsChanged", accountsChanged);
+          accountsChanged = void 0;
+        }
+        if (chainChanged) {
+          p.removeListener("chainChanged", chainChanged);
+          chainChanged = void 0;
+        }
+        if (disconnect) {
+          p.removeListener("disconnect", disconnect);
+          disconnect = void 0;
+        }
+      }
+    };
+  });
+}
+
+// src/index.ts
+function superfluidWallet(config = {}) {
+  const resolved = resolveSuperfluidWalletConfig(config);
+  const store = createProviderStore(resolved.storageKey);
+  return {
+    connectorId: resolved.connectorId,
+    connector: () => createSuperfluidWalletConnector(resolved, store)
+  };
+}
+
+exports.DEFAULT_CONNECTOR_ID = DEFAULT_CONNECTOR_ID;
+exports.DEFAULT_POPUP_TIMEOUT_MS = DEFAULT_POPUP_TIMEOUT_MS;
+exports.DEFAULT_STORAGE_KEY = DEFAULT_STORAGE_KEY;
+exports.DEFAULT_WALLET_URL = DEFAULT_WALLET_URL;
+exports.superfluidWallet = superfluidWallet;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map