@0xsequence/connect 5.0.0-ecosystem-beta → 5.0.0

package/src/hooks/useWallets.ts

@@ -1,227 +0,0 @@
-'use client'
-
-import { SequenceAPIClient, GetLinkedWalletsArgs, LinkedWallet } from '@0xsequence/api'
-import { useAPIClient } from '@0xsequence/react-hooks'
-import { useCallback, useEffect, useRef, useState } from 'react'
-import { Connector, type UseConnectionsReturnType, useAccount, useConnect, useConnections, useDisconnect } from 'wagmi'
-
-import { SEQUENCE_UNIVERSAL_CONNECTOR_NAME } from '../components/Connect/Connect'
-import { ExtendedConnector } from '../types'
-
-import { useWaasGetLinkedWalletsSignature } from './useWaasGetLinkedWalletsSignature'
-
-interface UseLinkedWalletsOptions {
-  enabled?: boolean
-}
-
-// Create a stable storage key from args
-const createStorageKey = (args: GetLinkedWalletsArgs): string =>
-  `@0xsequence.linked_wallets-${args.parentWalletAddress}-${args.signatureChainId}`
-
-const getLinkedWallets = async (
-  apiClient: SequenceAPIClient,
-  args: GetLinkedWalletsArgs,
-  headers?: object,
-  signal?: AbortSignal
-): Promise<Array<LinkedWallet>> => {
-  const storageKey = createStorageKey(args)
-  const now = Date.now()
-
-  // Check localStorage for cached data
-  const stored = localStorage.getItem(storageKey)
-  if (stored) {
-    try {
-      const { data, timestamp } = JSON.parse(stored)
-      // Check if cache is still valid (5 minutes)
-      if (now - timestamp <= 5 * 60 * 1000) {
-        return data
-      }
-    } catch (error) {
-      console.error('Error parsing stored linked wallets:', error)
-    }
-  }
-
-  // If no valid cache, fetch new data
-  const result = await apiClient.getLinkedWallets(args, headers, signal)
-  const linkedWallets = result.linkedWallets
-
-  // Store in localStorage with timestamp
-  localStorage.setItem(
-    storageKey,
-    JSON.stringify({
-      data: linkedWallets,
-      timestamp: now
-    })
-  )
-
-  return linkedWallets
-}
-
-export interface UseLinkedWalletsResult {
-  data: LinkedWallet[] | undefined
-  isLoading: boolean
-  error: Error | null
-  refetch: () => Promise<void>
-  clearCache: () => void
-}
-
-export const useLinkedWallets = (args: GetLinkedWalletsArgs, options: UseLinkedWalletsOptions = {}): UseLinkedWalletsResult => {
-  const apiClient = useAPIClient()
-  const [data, setData] = useState<LinkedWallet[] | undefined>(undefined)
-  const [isLoading, setIsLoading] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
-  const abortControllerRef = useRef<AbortController | undefined>(undefined)
-
-  const fetchData = useCallback(async () => {
-    if (!options.enabled) {
-      return
-    }
-
-    setIsLoading(true)
-    setError(null)
-
-    try {
-      // Cancel any ongoing request
-      abortControllerRef.current?.abort()
-      abortControllerRef.current = new AbortController()
-
-      const linkedWallets = await getLinkedWallets(apiClient, args, undefined, abortControllerRef.current.signal)
-
-      setData(linkedWallets)
-    } catch (error: unknown) {
-      if (error instanceof Error && error.name !== 'AbortError') {
-        setError(error)
-      } else if (error && typeof error === 'object' && 'name' in error && error.name !== 'AbortError') {
-        setError(new Error('Failed to fetch linked wallets'))
-      }
-    } finally {
-      setIsLoading(false)
-    }
-  }, [apiClient, args.parentWalletAddress, args.signatureChainId, options.enabled])
-
-  // Fetch on mount and when dependencies change
-  useEffect(() => {
-    fetchData()
-    return () => {
-      abortControllerRef.current?.abort()
-    }
-  }, [fetchData])
-
-  const clearCache = useCallback(() => {
-    localStorage.removeItem(createStorageKey(args))
-  }, [args])
-
-  const refetch = async () => {
-    clearCache()
-    await fetchData()
-  }
-
-  return {
-    data,
-    isLoading,
-    error,
-    refetch,
-    clearCache
-  }
-}
-
-export interface ConnectedWallet {
-  id: string
-  name: string
-  address: string
-  isActive: boolean
-  isEmbedded: boolean
-}
-
-export const useWallets = () => {
-  const { address } = useAccount()
-  const connections = useConnections()
-  const { connectAsync } = useConnect()
-  const { disconnectAsync } = useDisconnect()
-
-  const waasConnection = connections.find(c => (c.connector as ExtendedConnector)?.type === 'sequence-waas')
-
-  const {
-    message: linkedWalletsMessage,
-    signature: linkedWalletsSignature,
-    address: linkedWalletsWaasAddress,
-    chainId: linkedWalletsSigChainId
-  } = useWaasGetLinkedWalletsSignature(waasConnection)
-
-  // Only fetch if we have valid data
-  const hasValidData = !!(linkedWalletsWaasAddress && linkedWalletsMessage && linkedWalletsSignature)
-
-  const {
-    data: linkedWallets,
-    refetch: refetchLinkedWallets,
-    clearCache: clearLinkedWalletsCache
-  } = useLinkedWallets(
-    {
-      parentWalletAddress: linkedWalletsWaasAddress || '',
-      parentWalletMessage: linkedWalletsMessage || '',
-      parentWalletSignature: linkedWalletsSignature || '',
-      signatureChainId: `${linkedWalletsSigChainId}`
-    },
-    {
-      enabled: hasValidData
-    }
-  )
-
-  const wallets: ConnectedWallet[] = connections.map((connection: UseConnectionsReturnType[number]) => ({
-    id: connection.connector.id,
-    name: getConnectorName(connection.connector),
-    address: connection.accounts[0],
-    isActive: connection.accounts[0] === address,
-    isEmbedded: connection.connector.id.includes('waas')
-  }))
-
-  const setActiveWallet = async (walletAddress: string) => {
-    const connection = connections.find((c: UseConnectionsReturnType[number]) => c.accounts[0] === walletAddress)
-    if (!connection) {
-      return
-    }
-
-    try {
-      await connectAsync({ connector: connection.connector })
-    } catch (error) {
-      console.error('Failed to set active wallet:', error)
-    }
-  }
-
-  const disconnectWallet = async (walletAddress: string) => {
-    const connection = connections.find((c: UseConnectionsReturnType[number]) => c.accounts[0] === walletAddress)
-    if (!connection) {
-      return
-    }
-
-    // invalidate linked wallets if we're disconnecting waas wallet
-    if (connection.connector.id.includes('waas')) {
-      clearLinkedWalletsCache()
-    }
-
-    try {
-      await disconnectAsync({ connector: connection.connector })
-    } catch (error) {
-      console.error('Failed to disconnect wallet:', error)
-    }
-  }
-
-  return {
-    wallets,
-    linkedWallets,
-    setActiveWallet,
-    disconnectWallet,
-    refetchLinkedWallets
-  }
-}
-
-const getConnectorName = (connector: Connector) => {
-  const connectorName = connector.name
-  const connectorWalletName = (connector._wallet as any)?.name
-
-  if (connectorName === SEQUENCE_UNIVERSAL_CONNECTOR_NAME) {
-    return 'Sequence Universal'
-  }
-
-  return connectorWalletName ?? connectorName
-}

package/src/index.css

@@ -1,5 +0,0 @@
-@import 'tailwindcss';
-@import '@0xsequence/design-system/preset';
-
-@source '../../wallet/src';
-@source '../../checkout/src';

package/src/index.ts

@@ -1,111 +0,0 @@
-export { SequenceConnect } from './components/SequenceConnect'
-
-// Provider
-export { SequenceConnectProvider } from './components/SequenceConnectProvider'
-export { SequenceConnectPreviewProvider } from './components/SequenceConnectPreviewProvider'
-
-// Types
-export type {
-  Wallet,
-  WalletField,
-  WalletProperties,
-  WalletType,
-  DisplayedAsset,
-  ExtendedConnector,
-  EthAuthSettings,
-  ModalPosition,
-  ConnectConfig,
-  StorageItem
-} from './types'
-
-// Config
-export { createConfig, type CreateConfigOptions } from './config/createConfig'
-export {
-  getDefaultConnectors,
-  getDefaultWaasConnectors,
-  getDefaultUniversalConnectors,
-  type DefaultConnectorOptions,
-  type DefaultWaasConnectorOptions,
-  type DefaultUniversalConnectorOptions
-} from './config/defaultConnectors'
-export { getDefaultChains } from './config/defaultChains'
-export { getDefaultTransports } from './config/defaultTransports'
-
-// Constants
-export {
-  LocalStorageKey,
-  DEFAULT_SESSION_EXPIRATION,
-  TRANSACTION_CONFIRMATIONS_DEFAULT,
-  NATIVE_TOKEN_ADDRESS_0X,
-  QUERY_KEYS,
-  WEB_SDK_VERSION
-} from './constants'
-
-// Utils
-export { getConnectWallets } from './utils/getConnectWallets'
-export { isEmailValid, compareAddress, formatDisplay, capitalize, truncateAtMiddle, formatAddress } from './utils/helpers'
-export { getNativeTokenInfoByChainId, createNativeTokenBalance } from './utils/tokens'
-export { getModalPositionCss } from './utils/styling'
-export { getNetwork, getNetworkColor, getNetworkBackgroundColor } from './utils/networks'
-export { walletClientToSigner, publicClientToProvider } from './utils/adapters'
-export { signEthAuthProof, validateEthProof } from './utils/ethAuth'
-export { sendTransactions, waitForTransactionReceipt } from './utils/transactions'
-
-// Contexts
-export { useConnectConfigContext, ConnectConfigContextProvider } from './contexts/ConnectConfig'
-export { useAnalyticsContext, AnalyticsContextProvider } from './contexts/Analytics'
-export { useConnectModalContext, ConnectModalContextProvider } from './contexts/ConnectModal'
-export { useThemeContext, ThemeContextProvider } from './contexts/Theme'
-export { useWalletConfigContext, WalletConfigContextProvider } from './contexts/WalletConfig'
-
-// Connectors
-export { apple, type AppleOptions } from './connectors/apple'
-export { appleWaas, type AppleWaasOptions } from './connectors/apple/appleWaas'
-export { coinbaseWallet } from './connectors/coinbaseWallet'
-export { discord, type DiscordOptions } from './connectors/discord'
-export { email, type EmailOptions } from './connectors/email'
-export { emailWaas, type EmailWaasOptions } from './connectors/email/emailWaas'
-export { facebook, type FacebookOptions } from './connectors/facebook'
-export { google, type GoogleOptions } from './connectors/google'
-export { googleWaas, type GoogleWaasOptions } from './connectors/google/googleWaas'
-export { mock } from './connectors/mock'
-export { sequence, type SequenceOptions } from './connectors/sequence'
-export { twitch, type TwitchOptions } from './connectors/twitch'
-export { walletConnect } from './connectors/walletConnect'
-export { ecosystemWallet, type EcosystemWalletOptions } from './connectors/ecosystem'
-export {
-  sequenceWallet,
-  sequenceWaasWallet,
-  type BaseSequenceConnectorOptions,
-  type BaseSequenceWaasConnectorOptions
-} from './connectors/wagmiConnectors'
-
-// Hooks
-export { useOpenConnectModal } from './hooks/useOpenConnectModal'
-export { useTheme } from './hooks/useTheme'
-export { useWalletSettings } from './hooks/useWalletSettings'
-export { useWaasFeeOptions } from './hooks/useWaasFeeOptions'
-export { useCheckWaasFeeOptions } from './hooks/useCheckWaasFeeOptions'
-export { useWaasSignInEmail } from './hooks/useWaasSignInEmail'
-export { useSignInEmail } from './hooks/useSignInEmail'
-export { useProjectAccessKey } from './hooks/useProjectAccessKey'
-export { useStorage, useStorageItem } from './hooks/useStorage'
-export { useChain } from './hooks/useChain'
-export { useWallets } from './hooks/useWallets'
-export type { ConnectedWallet } from './hooks/useWallets'
-export type { LinkedWallet } from '@0xsequence/api'
-
-export { useDirectEcosystemConnect } from './hooks/useDirectEcosystemConnect'
-
-// Components
-export { NetworkBadge } from './components/NetworkBadge'
-export { CollectibleTileImage } from './components/CollectibleTileImage'
-export { CryptoOption } from './components/CryptoOption'
-export { SelectedIndicator } from './components/SelectedIndicator'
-export { ShadowRoot } from './components/ShadowRoot'
-
-// Indexer
-export { ContractVerificationStatus } from '@0xsequence/indexer'
-
-// XXX
-export { DEBUG } from './env'

package/src/types/provider.d.ts

@@ -1,9 +0,0 @@
-import '@0xsequence/provider'
-
-declare module '@0xsequence/provider' {
-  export enum AnalyticsEventType {
-    // Kit specific events
-    LINK_WALLET = 'LINK_WALLET',
-    UNLINK_WALLET = 'UNLINK_WALLET'
-  }
-}

package/src/types.ts

@@ -1,92 +0,0 @@
-import { ETHAuthProof } from '@0xsequence/auth'
-import { Theme } from '@0xsequence/design-system'
-import { FunctionComponent } from 'react'
-import { Connector, CreateConnectorFn } from 'wagmi'
-
-import { LocalStorageKey } from './constants'
-
-export interface LogoProps {
-  className?: string
-  style?: React.CSSProperties
-}
-
-export type WalletType = 'waas' | 'universal'
-
-export interface WalletProperties {
-  id: string
-  logoDark: FunctionComponent<LogoProps>
-  logoLight: FunctionComponent<LogoProps>
-  monochromeLogoDark?: FunctionComponent<LogoProps>
-  monochromeLogoLight?: FunctionComponent<LogoProps>
-  name: string
-  iconBackground?: string
-  hideConnectorId?: string | null
-  isSequenceBased?: boolean
-  type?: 'social' | 'wallet'
-}
-
-export type Wallet = WalletProperties & {
-  createConnector: (projectAccessKey: string) => CreateConnectorFn
-}
-
-export interface WalletField {
-  _wallet: WalletProperties
-}
-
-export type ExtendedConnector = Connector & WalletField
-
-export interface DisplayedAsset {
-  contractAddress: string
-  chainId: number
-}
-
-export interface EthAuthSettings {
-  app?: string
-  /** expiry number (in seconds) that is used for ETHAuth proof. Default is 1 week in seconds. */
-  expiry?: number
-  /** origin hint of the dapp's host opening the wallet. This value will automatically
-   * be determined and verified for integrity, and can be omitted. */
-  origin?: string
-  /** authorizeNonce is an optional number to be passed as ETHAuth's nonce claim for replay protection. **/
-  nonce?: number
-}
-
-export type ModalPosition =
-  | 'center'
-  | 'middle-right'
-  | 'middle-left'
-  | 'top-center'
-  | 'top-right'
-  | 'top-left'
-  | 'bottom-center'
-  | 'bottom-right'
-  | 'bottom-left'
-
-export interface ConnectConfig {
-  projectAccessKey: string
-  disableAnalytics?: boolean
-  defaultTheme?: Theme
-  position?: ModalPosition
-  signIn?: {
-    logoUrl?: string
-    descriptiveSocials?: boolean
-    projectName?: string
-    useMock?: boolean
-  }
-  displayedAssets?: DisplayedAsset[]
-  readOnlyNetworks?: number[]
-  ethAuth?: EthAuthSettings
-}
-
-export type StorageItem = {
-  [LocalStorageKey.EthAuthProof]: ETHAuthProof
-  [LocalStorageKey.EthAuthSettings]: EthAuthSettings
-  [LocalStorageKey.WaasEmailIdToken]: string
-  [LocalStorageKey.WaasGoogleClientID]: string
-  [LocalStorageKey.WaasGoogleIdToken]: string
-  [LocalStorageKey.WaasAppleClientID]: string
-  [LocalStorageKey.WaasAppleIdToken]: string
-  [LocalStorageKey.WaasAppleRedirectURI]: string
-  [LocalStorageKey.WaasActiveLoginType]: string
-  [LocalStorageKey.WaasSignInEmail]: string
-}

package/src/utils/adapters.ts

@@ -1,29 +0,0 @@
-import { ethers } from 'ethers'
-import { type HttpTransport, Account, Chain, Client, Transport } from 'viem'
-
-export const walletClientToSigner = async (walletClient: Client<Transport, Chain, Account>) => {
-  const { account, chain, transport } = walletClient
-  const network = {
-    chainId: chain.id,
-    name: chain.name,
-    ensAddress: chain.contracts?.ensRegistry?.address
-  }
-  const provider = new ethers.BrowserProvider(transport, network)
-  const signer = await provider.getSigner(account.address)
-  return signer
-}
-
-export const publicClientToProvider = (publicClient: Client<Transport, Chain>) => {
-  const { chain, transport } = publicClient
-  const network = {
-    chainId: chain.id,
-    name: chain.name,
-    ensAddress: chain.contracts?.ensRegistry?.address
-  }
-  if (transport.type === 'fallback') {
-    return new ethers.FallbackProvider(
-      (transport.transports as ReturnType<HttpTransport>[]).map(({ value }) => new ethers.JsonRpcProvider(value?.url, network))
-    )
-  }
-  return new ethers.JsonRpcProvider(transport.url, network)
-}

package/src/utils/deferred.ts

@@ -1,21 +0,0 @@
-export class Deferred<T> {
-  private _resolve: (value: T) => void = () => {}
-  private _reject: (value: T) => void = () => {}
-
-  private _promise: Promise<T> = new Promise<T>((resolve, reject) => {
-    this._reject = reject
-    this._resolve = resolve
-  })
-
-  get promise(): Promise<T> {
-    return this._promise
-  }
-
-  resolve(value: T) {
-    this._resolve(value)
-  }
-
-  reject(value: T) {
-    this._reject(value)
-  }
-}

package/src/utils/ethAuth.ts

@@ -1,70 +0,0 @@
-import { ETHAuthProof } from '@0xsequence/auth'
-import { ETHAuth, Proof } from '@0xsequence/ethauth'
-import { isValidTypedDataSignature } from '@0xsequence/provider'
-import { UsePublicClientReturnType, Storage } from 'wagmi'
-import { GetWalletClientData } from 'wagmi/query'
-
-import { LocalStorageKey, DEFAULT_SESSION_EXPIRATION } from '../constants'
-import { StorageItem } from '../types'
-
-import { publicClientToProvider, walletClientToSigner } from './adapters'
-
-export const signEthAuthProof = async (
-  walletClient: GetWalletClientData<any, any>,
-  storage: Storage<StorageItem>
-): Promise<ETHAuthProof> => {
-  const proofInformation = await storage.getItem(LocalStorageKey.EthAuthProof)
-
-  // if proof information was generated and saved upon wallet connection, use that
-  if (proofInformation) {
-    return proofInformation
-  }
-
-  // generate a new proof
-  const proofSettings = await storage.getItem(LocalStorageKey.EthAuthSettings)
-
-  if (!proofSettings) {
-    throw new Error('No ETHAuth settings found')
-  }
-
-  const walletAddress = walletClient.account.address
-
-  const proof = new Proof()
-  proof.address = walletAddress
-
-  proof.claims.app = proofSettings.app || 'app'
-  proof.claims.ogn = proofSettings.origin
-  proof.claims.n = proofSettings.nonce
-
-  proof.setExpiryIn(proofSettings.expiry ? Math.max(proofSettings.expiry, 200) : DEFAULT_SESSION_EXPIRATION)
-
-  const typedData = proof.messageTypedData()
-  const signer = await walletClientToSigner(walletClient)
-  const signature = await signer.signTypedData(typedData.domain, typedData.types, typedData.message)
-
-  proof.signature = signature
-
-  const ethAuth = new ETHAuth()
-  const proofString = await ethAuth.encodeProof(proof, true)
-
-  return {
-    typedData,
-    proofString
-  }
-}
-
-export const validateEthProof = async (
-  walletClient: GetWalletClientData<any, any>,
-  publicClient: UsePublicClientReturnType<any, any>,
-  proof: ETHAuthProof
-): Promise<boolean> => {
-  const walletAddress = walletClient.account.address
-  const ethAuth = new ETHAuth()
-
-  const decodedProof = await ethAuth.decodeProof(proof.proofString, true)
-  const provider = publicClientToProvider(publicClient)
-
-  const isValid = await isValidTypedDataSignature(walletAddress, proof.typedData, decodedProof.signature, provider)
-
-  return isValid
-}

package/src/utils/getConnectWallets.ts

@@ -1,25 +0,0 @@
-import { CreateConnectorFn } from 'wagmi'
-
-import { ExtendedConnector, Wallet } from '../types'
-
-export const getConnectWallets = (projectAccessKey: string, wallets: Wallet[]): CreateConnectorFn[] => {
-  const connectors: CreateConnectorFn[] = []
-
-  wallets.forEach(wallet => {
-    const { createConnector, ...metaProperties } = wallet
-    const walletProperties = { ...metaProperties }
-
-    const createConnectorOverride = (config: any) => {
-      const connector = createConnector(projectAccessKey)
-
-      const res = connector(config) as ExtendedConnector
-      res._wallet = { ...walletProperties }
-
-      return res
-    }
-
-    connectors.push(createConnectorOverride)
-  })
-
-  return connectors
-}