SDK Types & Enums

interface WalletConnectKitConfig {
  clientId?: string
  connectors?: WalletConfig[]
  chains?: Partial<Record<ChainType, EvmChain[] | any[]>>
  walletConnectConfig?: WalletConnectConfig
}

import { type WalletConnectKitConfig } from "@dogeos/dogeos-sdk"
import { mainnet, base } from "viem/chains"

const config: WalletConnectKitConfig = {
  clientId: "YOUR_CLIENT_ID",
  chains: {
    evm: [mainnet, base],
  },
}

type WalletConnectConfig = {
  projectId: string
  metadata: {
    name: string
    description: string
    url: string
    icons: string[]
  }
  relayUrl?: string
}

interface UseWalletConnectReturn {
  isOpenModal: boolean
  isConnected: boolean
  isConnecting: boolean
  error: string
  connect: (variables: ConnectVariables) => Promise<ConnectData>
  disconnect: () => Promise<void>
  openModal: () => void
  closeModal: () => void
}

interface UseAccountReturn {
  address: string
  balance?: string
  chainType?: ChainType
  chainId?: string
  currentWallet?: Connector | null
  currentProvider?: any
  switchChain: (options: SwitchChainOptions) => Promise<boolean>
  signMessage?: (params: SignMessageParams) => Promise<string | Uint8Array>
  signInWithWallet: (params?: SignInParams) => Promise<string | Uint8Array>
}

interface UseEmbeddedWalletReturn {
  wallet: any | undefined
  isAvailable: boolean
  message: string | null
  connectedInfo: ConnectData | undefined
  isLoading: boolean
}

interface ConnectVariables {
  wallet: Connector
  chainType: ChainType
  chainId?: string
}

interface ConnectData {
  address: string
  chainId: string
  chainType: ChainType
}

type ConnectErrorType = Error

type SwitchChainOptions = {
  chainType: ChainType
  chainInfo: Chain
}

import { useAccount } from "@dogeos/dogeos-sdk"
import { base } from "viem/chains"

const { switchChain } = useAccount()

const success = await switchChain({
  chainType: "evm",
  chainInfo: base,
})

type Chain = {
  id: number
  name: string
  nativeCurrency: {
    name: string
    symbol: string
    decimals: number
  }
  rpcUrls: {
    default: {
      http: string[]
    }
  }
  blockExplorers?: {
    default: {
      name: string
      url: string
    }
  }
  testnet?: boolean
  chainInfo?: ChainInfo
}

import { mainnet, base, sepolia } from "viem/chains"

type ChainInfo = {
  icon: any
  name: string
}

type ChainType = "evm" | "solana" | "aptos" | "dogecoin"

// Correct
connect({ wallet, chainType: "evm" })

// Also works but unnecessary
connect({ wallet, chainType: ChainTypeEnum.EVM })

interface Connector {
  info: WalletInfo
  isInstalled?: boolean
  recommoned?: boolean
  providers: {
    evm?: ConnectorProvider
    solana?: ConnectorProvider
    aptos?: ConnectorProvider
    dogecoin?: ConnectorProvider
  }
}

interface ConnectorProvider {
  provider: any
  protocol: ProviderProtocol
}

interface WalletInfo {
  uuid: string
  name: string
  sameNames?: string[]
  namespace?: string
  icon: string
  iconBackground?: string
  rdns?: string
  isWalletConnect?: boolean
  deeplink?: string
  mobile?: {
    getUri?: (uri: string) => string
    getDeeplink?: (dappUrl?: string, chainId?: number) => string | Promise<string>
  }
  links: {
    homepage?: string
    ios_install?: string
    android_install?: string
    chrome_install?: string
    mobile?: string
    qrCode?: string
    edge?: string
    firefox?: string
    opera?: string
    safari?: string
    macos?: string
    windows?: string
    linux?: string
    desktop?: string
  }
}

type WalletConfig = {
  id: string
  name: string
  rdns?: string
  namespace?: string
  flag?: string
  solana?: { namespace?: string; flag?: string }
  aptos?: { namespace?: string; flag?: string }
  dogecoin?: { namespace?: string; flag?: string }
  icon: string
  iconAccent?: string
  iconBackground: string
  installed?: boolean
  mobileUserAgent?: string
  deeplink?: string
  downloadUrls?: {
    android?: string
    ios?: string
    mobile?: string
    qrCode?: string
    chrome?: string
    edge?: string
    firefox?: string
    opera?: string
    safari?: string
    browserExtension?: string
    macos?: string
    windows?: string
    linux?: string
    desktop?: string
  }
  mobile?: {
    getUri?: (uri: string) => string
    getDeeplink?: (dappUrl?: string, chainId?: number) => string | Promise<string>
  }
}

interface WalletProvider {
  uuid: string
  name: string
  namespace?: string
  icon: string
  iconBackground?: string
  rdns?: string
  links: {
    homepage?: string
    ios_install?: string
    android_install?: string
    chrome_install?: string
    mobile?: string
    qrCode?: string
    edge?: string
    firefox?: string
    opera?: string
    safari?: string
    macos?: string
    windows?: string
    linux?: string
    desktop?: string
  }
}

type SignMessageParams = {
  message: string
  nonce?: string
}

const { signMessage } = useAccount()

const signature = await signMessage?.({
  message: "Welcome to DogeOS!",
  nonce: Math.random().toString(36).slice(2),
})

interface SignInParams {
  scheme?: "https" | "http"
  domain: string
  uri?: string
  chainId?: string
  address?: string
  statement: string
  version?: string
  nonce: string
  issuedAt?: string
  resources?: `https://${string}`[]
}

const { signInWithWallet } = useAccount()

const token = await signInWithWallet({
  domain: window.location.host,
  statement: "Sign in to DogeOS",
  nonce: Math.random().toString(36).slice(2),
  issuedAt: new Date().toISOString(),
})

enum ChainTypeEnum {
  All = "all",
  EVM = "evm",
  Solana = "solana",
  Aptos = "aptos",
}

enum ModalView {
  Loading = "LOADING",
  Logged = "LOGGED",
  WalletList = "WALLET_LIST",
  WalletSearch = "WALLET_SEARCH",
  WalletSelectProviders = "WALLET_SELECT_PROVIDERS",
  WalletInstallGuide = "WALLET_INSTALL_GUIDE",
  Connecting = "CONNECTING",
  Error = "ERROR",
  Account = "ACCOUNT",
  SelectChains = "SELECT_CHAINS",
  ChangeNetwork = "CHANGE_NETWORK",
  SignInWallet = "SIGN_IN_WALLET",
  WalletConnect = "WALLET_CONNECT",
  UnsupportChain = "UNSUPPORT_CHAIN",
  SocialLogin = "SOCIAL_LOGIN",
  MyDogeSocialLogin = "MYDOGE_SOCIAL_LOGIN",
}

enum ProdTypeEnum {
  Tomo = "tomo",
  MyDoge = "mydoge",
  WLFI = "wlfi",
}

useWalletConnect()
  └─ UseWalletConnectReturn
      ├─ connect(ConnectVariables) → Promise<ConnectData>
      │   └─ ConnectVariables { wallet: Connector, chainType, chainId? }
      ├─ disconnect() → Promise<void>
      ├─ openModal() / closeModal()
      └─ isOpenModal, isConnected, isConnecting, error

useAccount()
  └─ UseAccountReturn
      ├─ address, balance, chainType, chainId
      ├─ currentWallet: Connector
      ├─ currentProvider: EIP-1193 Provider
      ├─ switchChain(SwitchChainOptions) → Promise<boolean>
      │   └─ SwitchChainOptions { chainType, chainInfo: Chain }
      ├─ signMessage(SignMessageParams) → Promise<string | Uint8Array>
      └─ signInWithWallet(SignInParams) → Promise<string | Uint8Array>

useEmbeddedWallet()
  └─ UseEmbeddedWalletReturn
      ├─ wallet, isAvailable, isLoading
      ├─ message: string | null
      └─ connectedInfo: ConnectData

WalletConnectKitConfig (configuration)
  ├─ clientId → SDK authentication
  ├─ connectors: WalletConfig[] → Available wallets
  ├─ chains: Record<ChainType, Chain[]> → Supported networks
  └─ walletConnectConfig → WalletConnect protocol

        ↓ (at runtime)

useAccount() returns:
  ├─ currentWallet: Connector (from connectors)
  └─ chainId, chainType (from chains)

import type { WalletConnectKitConfig } from "@dogeos/dogeos-sdk"
import { mainnet, base } from "viem/chains"

const config: WalletConnectKitConfig = {
  clientId: "YOUR_CLIENT_ID",
  chains: { evm: [mainnet, base] },
}

const { connect } = useWalletConnect()

const data = await connect({
  wallet: myConnector,
  chainType: "evm",
  chainId: "0x1",
})
console.log("Connected:", data.address)

const { signMessage } = useAccount()

const signature = await signMessage?.({
  message: "Hello, DogeOS!",
  nonce: crypto.randomUUID(),
})

import { base } from "viem/chains"

const { switchChain } = useAccount()

const success = await switchChain({
  chainType: "evm",
  chainInfo: base,
})

const { currentProvider, address } = useAccount()

if (currentProvider) {
  const balance = await currentProvider.request({
    method: "eth_getBalance",
    params: [address, "latest"],
  })
}