@multiplatform.one/web3 5.0.27

package/src/connectkit/connectors/walletAdapterConnector.ts

@@ -0,0 +1,138 @@
+import { createConnector } from 'wagmi';
+import type { Address } from 'viem';
+import type { WalletAdapter } from '../adapters/types';
+import { syntheticChainIdByEcosystem } from './syntheticChains';
+import type { Ecosystem } from '../utils';
+
+export interface SiwwConnectorEntry {
+  /** Stable id, e.g. "siww:solana:phantom" — also the walletConfigs key. */
+  id: string;
+  /** Display name, e.g. "Phantom" / "UniSat". */
+  name: string;
+  /** Non-EVM ecosystem this wallet signs for. */
+  ecosystem: Exclude<Ecosystem, 'evm'>;
+  /** Ready-to-drive siww adapter. */
+  adapter: WalletAdapter;
+  /** Optional icon (data-uri/url). walletConfigs usually supplies this instead. */
+  icon?: string;
+}
+
+type ProviderListener = (payload?: unknown) => void;
+
+/**
+ * Wrap a siww `WalletAdapter` (Solana/Sui/Bitcoin) as a wagmi connector so it rides
+ * ConnectKit's existing useWallets → ConnectorList → ConnectUsing → Injector path
+ * with no UI changes. wagmi only ever sees an EIP-1193-ish provider; the real
+ * connect/sign is the adapter's. The address is cast to viem `Address` purely to
+ * satisfy wagmi's types — it is NEVER used as a real EVM address (only displayed,
+ * and handed to Keycloak as the signed message's account). Modeled on
+ * createBridgeConnector (see ../../bridge/bridgeConnector.ts).
+ */
+export function walletAdapterConnector(entry: SiwwConnectorEntry) {
+  const chainId = syntheticChainIdByEcosystem[entry.ecosystem];
+
+  return createConnector((config) => {
+    const listeners: Record<string, Set<ProviderListener>> = {};
+
+    // Minimal EIP-1193-ish provider backed by the adapter. `personal_sign` routes
+    // to adapter.signMessage and returns the chain-native signature (base58/base64)
+    // untouched — Keycloak content-sniffs the chain from the message body.
+    const provider = {
+      async request({ method, params }: { method: string; params?: unknown[] }) {
+        switch (method) {
+          case 'eth_requestAccounts':
+          case 'eth_accounts':
+            return entry.adapter.address ? [entry.adapter.address] : [];
+          case 'eth_chainId':
+            return `0x${chainId.toString(16)}`;
+          case 'personal_sign':
+          case 'eth_sign': {
+            const raw = (params?.[0] as string) ?? '';
+            return entry.adapter.signMessage(decodeMaybeHex(raw));
+          }
+          case 'wallet_switchEthereumChain':
+            return null;
+          default:
+            throw new Error(`siww provider: unsupported method ${method}`);
+        }
+      },
+      on(event: string, listener: ProviderListener) {
+        (listeners[event] ??= new Set()).add(listener);
+      },
+      removeListener(event: string, listener: ProviderListener) {
+        listeners[event]?.delete(listener);
+      },
+    };
+
+    const connector = {
+      id: entry.id,
+      name: entry.name,
+      type: 'siww' as const,
+      icon: entry.icon,
+      // custom tag read by getConnectorEcosystem()/WalletProps.ecosystem
+      ecosystem: entry.ecosystem,
+
+      async getProvider() {
+        return provider;
+      },
+      async getChainId() {
+        return chainId;
+      },
+      async getAccounts() {
+        return entry.adapter.address
+          ? [entry.adapter.address as Address]
+          : ([] as readonly Address[]);
+      },
+      async connect() {
+        await entry.adapter.connect();
+        if (!entry.adapter.address)
+          throw new Error(`${entry.name} returned no account`);
+        return {
+          accounts: [entry.adapter.address as Address] as readonly Address[],
+          chainId,
+        };
+      },
+      async disconnect() {
+        await entry.adapter.disconnect().catch(() => undefined);
+      },
+      async isAuthorized() {
+        return entry.adapter.isConnected && !!entry.adapter.address;
+      },
+      onAccountsChanged(accounts: string[]) {
+        if (accounts.length === 0) config.emitter.emit('disconnect');
+        else
+          config.emitter.emit('change', {
+            accounts: accounts as readonly Address[],
+          });
+      },
+      onChainChanged() {
+        config.emitter.emit('change', { chainId });
+      },
+      onDisconnect() {
+        config.emitter.emit('disconnect');
+      },
+    };
+
+    // Same cast rationale as bridgeConnector: the shape is exact except for wagmi's
+    // EIP-5792 capabilities generic, which a non-EVM wallet does not implement.
+    return connector as unknown as ReturnType<
+      Parameters<typeof createConnector>[0]
+    >;
+  });
+}
+
+/** EVM `personal_sign` hex-encodes the message; decode back to UTF-8 if it's 0x-hex. */
+function decodeMaybeHex(raw: string): string {
+  if (typeof raw === 'string' && raw.startsWith('0x')) {
+    try {
+      const hex = raw.slice(2);
+      const bytes = new Uint8Array(hex.length / 2);
+      for (let i = 0; i < bytes.length; i++)
+        bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+      return new TextDecoder().decode(bytes);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}

package/src/connectkit/constants/chainConfigs.tsx

@@ -0,0 +1,331 @@
+import { ReactNode } from 'react';
+import Logos from '../assets/chains';
+
+type Chain = {
+  id: number;
+  name: string;
+  logo: ReactNode;
+  rpcUrls?: {
+    // https://github.com/wevm/viem/tree/1.x.x/src/chains/definitions
+    alchemy?: {
+      http?: string[];
+      webSocket?: string[];
+    };
+    infura?: {
+      http?: string[];
+      webSocket?: string[];
+    };
+  };
+};
+
+// Note: these rpcUrls are incomplete, and are subject to change from their respective providers
+// More RPC URLs can be found: https://chainid.network/chains.json
+
+export const chainConfigs: Chain[] = [
+  {
+    id: 1,
+    name: 'Ethereum',
+    logo: <Logos.Ethereum />,
+    rpcUrls: {
+      alchemy: {
+        http: ['https://eth-mainnet.g.alchemy.com/v2'],
+        webSocket: ['wss://eth-mainnet.g.alchemy.com/v2'],
+      },
+      infura: {
+        http: ['https://mainnet.infura.io/v3'],
+        webSocket: ['wss://mainnet.infura.io/ws/v3'],
+      },
+    },
+  },
+  {
+    id: 232,
+    name: 'Lens Chain',
+    logo: <Logos.LensChain />,
+  },
+  {
+    id: 37111,
+    name: 'Lens Chain Testnet',
+    logo: <Logos.LensChain testnet />,
+  },
+  {
+    id: 3,
+    name: 'Rinkeby',
+    logo: <Logos.Ethereum testnet />,
+    rpcUrls: {},
+  },
+  {
+    id: 4,
+    name: 'Ropsten',
+    logo: <Logos.Ethereum testnet />,
+  },
+  {
+    id: 5,
+    name: 'Görli',
+    logo: <Logos.Ethereum testnet />,
+  },
+  {
+    id: 42,
+    name: 'Kovan',
+    logo: <Logos.Ethereum testnet />,
+  },
+  {
+    id: 10,
+    name: 'Optimism',
+    logo: <Logos.Optimism />,
+  },
+  {
+    id: 69, // nice
+    name: 'Optimism Kovan',
+    logo: <Logos.Optimism testnet />,
+  },
+  {
+    id: 420, // nice
+    name: 'Optimism Goerli',
+    logo: <Logos.Optimism testnet />,
+  },
+  {
+    id: 11155420,
+    name: 'Optimism Sepolia',
+    logo: <Logos.Optimism testnet />,
+  },
+  {
+    id: 137,
+    name: 'Polygon',
+    logo: <Logos.Polygon />,
+  },
+  {
+    id: 80001,
+    name: 'Polygon Mumbai',
+    logo: <Logos.Polygon testnet />,
+  },
+  {
+    id: 31337,
+    name: 'Hardhat',
+    logo: <Logos.Ethereum testnet />,
+  },
+  {
+    id: 1337,
+    name: 'Localhost',
+    logo: <Logos.Ethereum testnet />,
+  },
+  {
+    id: 42161,
+    name: 'Arbitrum',
+    logo: <Logos.Arbitrum />,
+    rpcUrls: {
+      alchemy: {
+        http: ['https://arb-mainnet.g.alchemy.com/v2'],
+        webSocket: ['wss://arb-mainnet.g.alchemy.com/v2'],
+      },
+      infura: {
+        http: ['https://arbitrum-mainnet.infura.io/v3'],
+        webSocket: ['wss://arbitrum-mainnet.infura.io/ws/v3'],
+      },
+    },
+  },
+  {
+    id: 421611,
+    name: 'Arbitrum Rinkeby',
+    logo: <Logos.Arbitrum testnet />,
+  },
+  {
+    id: 421613,
+    name: 'Arbitrum Goerli',
+    logo: <Logos.Arbitrum testnet />,
+    rpcUrls: {
+      alchemy: {
+        http: ['https://arb-goerli.g.alchemy.com/v2'],
+        webSocket: ['wss://arb-goerli.g.alchemy.com/v2'],
+      },
+      infura: {
+        http: ['https://arbitrum-goerli.infura.io/v3'],
+        webSocket: ['wss://arbitrum-goerli.infura.io/ws/v3'],
+      },
+    },
+  },
+  {
+    id: 40,
+    name: 'Telos',
+    logo: <Logos.Telos />,
+  },
+  {
+    id: 41,
+    name: 'Telos Testnet',
+    logo: <Logos.Telos testnet />,
+  },
+  {
+    id: 1313161554,
+    name: 'Aurora',
+    logo: <Logos.Aurora />,
+  },
+  {
+    id: 1313161555,
+    name: 'Aurora Testnet',
+    logo: <Logos.Aurora testnet />,
+  },
+  {
+    id: 43_114,
+    name: 'Avalanche',
+    logo: <Logos.Avalanche />,
+  },
+  {
+    id: 43_113,
+    name: 'Avalanche Fuji',
+    logo: <Logos.Avalanche testnet />,
+  },
+  {
+    id: 31337,
+    name: 'Foundry',
+    logo: <Logos.Foundry testnet />,
+  },
+  {
+    id: 100,
+    name: 'Gnosis',
+    logo: <Logos.Gnosis />,
+  },
+  {
+    id: 9001,
+    name: 'Evmos',
+    logo: <Logos.Evmos />,
+  },
+  {
+    id: 9000,
+    name: 'Evmos Testnet',
+    logo: <Logos.Evmos testnet />,
+  },
+  {
+    id: 56,
+    name: 'BNB Smart Chain',
+    logo: <Logos.BinanceSmartChain />,
+  },
+  {
+    id: 97,
+    name: 'Binance Smart Chain Testnet',
+    logo: <Logos.BinanceSmartChain testnet />,
+  },
+  {
+    id: 11155111,
+    name: 'Sepolia',
+    logo: <Logos.Sepolia />,
+  },
+  {
+    id: 841,
+    name: 'Taraxa',
+    logo: <Logos.Taraxa />,
+  },
+  {
+    id: 842,
+    name: 'Taraxa Testnet',
+    logo: <Logos.Taraxa testnet />,
+  },
+  {
+    id: 324,
+    name: 'zkSync',
+    logo: <Logos.zkSync />,
+  },
+  {
+    id: 280,
+    name: 'zkSync Testnet',
+    logo: <Logos.zkSync testnet />,
+  },
+  {
+    id: 42_220,
+    name: 'Celo',
+    logo: <Logos.Celo />,
+  },
+  {
+    id: 44_787,
+    name: 'Celo Alfajores',
+    logo: <Logos.Celo testnet />,
+  },
+  {
+    id: 7_700,
+    name: 'Canto',
+    logo: <Logos.Canto />,
+  },
+  {
+    id: 250,
+    name: 'Fantom',
+    logo: <Logos.Fantom />,
+  },
+  {
+    id: 4_002,
+    name: 'Fantom Testnet',
+    logo: <Logos.Fantom testnet />,
+  },
+  {
+    id: 14,
+    name: 'Flare',
+    logo: <Logos.Flare />,
+  },
+  {
+    id: 114,
+    name: 'Coston2',
+    logo: <Logos.Flare />,
+  },
+  {
+    id: 314,
+    name: 'Filecoin',
+    logo: <Logos.Filecoin />,
+  },
+  {
+    id: 314_1,
+    name: 'Filecoin Hyperspace',
+    logo: <Logos.Filecoin testnet />,
+  },
+  {
+    id: 314_159,
+    name: 'Filecoin Calibration',
+    logo: <Logos.Filecoin testnet />,
+  },
+  {
+    id: 1_088,
+    name: 'Metis',
+    logo: <Logos.Metis />,
+  },
+  {
+    id: 599,
+    name: 'Metis Goerli',
+    logo: <Logos.Metis testnet />,
+  },
+  {
+    id: 4_689,
+    name: 'IoTeX',
+    logo: <Logos.IoTeX />,
+  },
+  {
+    id: 4_690,
+    name: 'IoTeX Testnet',
+    logo: <Logos.IoTeX testnet />,
+  },
+  {
+    id: 8_453,
+    name: 'Base',
+    logo: <Logos.Base />,
+  },
+  {
+    id: 84_531,
+    name: 'Base Goerli',
+    logo: <Logos.Base testnet />,
+  },
+  {
+    id: 84_532,
+    name: 'Base Sepolia',
+    logo: <Logos.Base testnet />,
+  },
+  {
+    id: 7777777,
+    name: 'Zora',
+    logo: <Logos.Zora />,
+  },
+  {
+    id: 999999999,
+    name: 'Zora Sepolia',
+    logo: <Logos.Zora testnet />,
+  },
+  {
+    id: 999,
+    name: 'Zora Goerli Testnet',
+    logo: <Logos.Zora testnet />,
+  },
+];

package/src/connectkit/constants/defaultTheme.ts

@@ -0,0 +1,3 @@
+export default {
+  mobileWidth: 560,
+};

package/src/connectkit/defaultConfig.ts

@@ -0,0 +1,96 @@
+import { http } from 'wagmi';
+import { type CreateConfigParameters } from '@wagmi/core';
+import { mainnet, polygon, optimism, arbitrum } from 'wagmi/chains';
+import { CoinbaseWalletParameters } from 'wagmi/connectors';
+import { EthereumProviderOptions as AaveAccountOptions } from '@aave/account';
+
+import defaultConnectors from './defaultConnectors';
+import { getSiwwConnectors } from './connectors/getSiwwConnectors';
+import { syntheticChains } from './connectors/syntheticChains';
+
+// TODO: Move these to a provider rather than global variable
+let globalAppName: string;
+let globalAppIcon: string;
+export const getAppName = () => globalAppName;
+export const getAppIcon = () => globalAppIcon;
+
+type DefaultConfigProps = {
+  appName: string;
+  appIcon?: string;
+  appDescription?: string;
+  appUrl?: string;
+
+  // WC 2.0 requires a project ID (get one here: https://cloud.walletconnect.com/sign-in)
+  walletConnectProjectId: string;
+  // Coinbase Wallet preference
+  coinbaseWalletPreference?: CoinbaseWalletParameters<'4'>['preference'];
+  // Aave Account options
+  enableAaveAccount?: boolean;
+  aaveAccountOptions?: AaveAccountOptions;
+  // siww: append shim-connectors for any detected non-EVM wallet (Solana/Sui/
+  // Bitcoin) alongside the EVM connectors. No-op when none are installed.
+  enableSiww?: boolean;
+} & Partial<CreateConfigParameters>;
+
+const defaultConfig = ({
+  appName = 'ConnectKit',
+  appIcon,
+  appDescription,
+  appUrl,
+  walletConnectProjectId,
+  coinbaseWalletPreference,
+  chains = [mainnet, polygon, optimism, arbitrum],
+  client,
+  enableAaveAccount = true,
+  aaveAccountOptions,
+  enableSiww = true,
+  ...props
+}: DefaultConfigProps): CreateConfigParameters => {
+  globalAppName = appName;
+  if (appIcon) globalAppIcon = appIcon;
+
+  // Register the siww synthetic chains so wagmi can resolve a `chain` object for a
+  // connected non-EVM account — ConnectKit's SIWE signIn reads `chain.id`, which is
+  // undefined otherwise ("No chainId found"). They carry no real RPC and are never
+  // used for transactions.
+  const allChains = (
+    enableSiww ? [...chains, ...syntheticChains] : chains
+  ) as typeof chains;
+
+  // TODO: nice to have, automate transports based on chains, but for now just provide public if not provided
+  const transports: CreateConfigParameters['transports'] =
+    props?.transports ??
+    Object.fromEntries(allChains.map((chain) => [chain.id, http()]));
+
+  const baseConnectors: CreateConfigParameters['connectors'] =
+    props?.connectors ??
+    defaultConnectors({
+      app: {
+        name: appName,
+        icon: appIcon,
+        description: appDescription,
+        url: appUrl,
+      },
+      walletConnectProjectId,
+      coinbaseWalletPreference,
+      enableAaveAccount,
+      aaveAccountOptions,
+    });
+
+  // Append siww shim-connectors for detected non-EVM wallets. discoverWallets()
+  // returns [] under SSR / when none are installed, so this is a safe no-op there.
+  const connectors: CreateConfigParameters['connectors'] = enableSiww
+    ? [...(baseConnectors ?? []), ...getSiwwConnectors()]
+    : baseConnectors;
+
+  const config: CreateConfigParameters<any, any> = {
+    ...props,
+    chains: allChains,
+    connectors,
+    transports,
+  };
+
+  return config;
+};
+
+export default defaultConfig;

package/src/connectkit/defaultConnectors.ts

@@ -0,0 +1,89 @@
+import { CreateConnectorFn } from 'wagmi';
+import {
+  injected,
+  walletConnect,
+  coinbaseWallet,
+  CoinbaseWalletParameters,
+  safe,
+} from '@wagmi/connectors';
+
+import {
+  EthereumProviderOptions as AaveAccountOptions,
+  aaveAccountConnector,
+} from '@aave/account';
+
+type DefaultConnectorsProps = {
+  app: {
+    name: string;
+    icon?: string;
+    description?: string;
+    url?: string;
+  };
+  walletConnectProjectId?: string;
+  coinbaseWalletPreference?: CoinbaseWalletParameters<'4'>['preference'];
+  enableAaveAccount?: boolean;
+  aaveAccountOptions?: AaveAccountOptions;
+};
+
+const defaultConnectors = ({
+  app,
+  walletConnectProjectId,
+  coinbaseWalletPreference,
+  enableAaveAccount,
+  aaveAccountOptions,
+}: DefaultConnectorsProps): CreateConnectorFn[] => {
+  const hasAllAppData = app.name && app.icon && app.description && app.url;
+  const shouldUseSafeConnector =
+    !(typeof window === 'undefined') && window?.parent !== window;
+
+  const connectors: CreateConnectorFn[] = enableAaveAccount
+    ? [aaveAccountConnector(aaveAccountOptions)]
+    : [];
+
+  // If we're in an iframe, include the SafeConnector
+  if (shouldUseSafeConnector) {
+    connectors.push(
+      safe({
+        allowedDomains: [/gnosis-safe.io$/, /app.safe.global$/],
+      })
+    );
+  }
+
+  // Add the rest of the connectors
+  connectors.push(
+    injected({ target: 'metaMask' }),
+    coinbaseWallet({
+      appName: app.name,
+      appLogoUrl: app.icon,
+      preference: coinbaseWalletPreference,
+    })
+  );
+
+  if (walletConnectProjectId) {
+    connectors.push(
+      walletConnect({
+        showQrModal: false,
+        projectId: walletConnectProjectId,
+        metadata: hasAllAppData
+          ? {
+              name: app.name,
+              description: app.description!,
+              url: app.url!,
+              icons: [app.icon!],
+            }
+          : undefined,
+      })
+    );
+  }
+  /*
+  connectors.push(
+    injected({
+      shimDisconnect: true,
+    })
+  );
+  */
+
+  return connectors;
+};
+
+export default defaultConnectors;