useWallets

type Request = {
  hook: 'useWallets',
  params: [options?: WalletOptions]
}
 
type WalletOptions = {
  chainId?: number
  onSuccess?: (data: SetActiveWalletResult | CreateWalletResult) => void
  onError?: (error: OpenfortError) => void
  onSettled?: (data: SetActiveWalletResult | CreateWalletResult | undefined | null, error: OpenfortError | null) => void
  throwOnError?: boolean
}
 
type OpenfortError = {
  message: string
  type: OpenfortErrorType
  data: { [key: string]: any }
  name: string
}
 
enum OpenfortErrorType {
  AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
  WALLET_ERROR = "WALLET_ERROR",
  CONFIGURATION_ERROR = "CONFIGURATION_ERROR",
  VALIDATION_ERROR = "VALIDATION_ERROR",
}

type Response = UseWalletsReturn
 
type UseWalletsReturn = WalletFlowFlags & {
  wallets: UserWallet[]
  activeWallet: UserWallet | null
  setActiveWallet(options?: SetActiveWalletOptions): Promise<SetActiveWalletResult>
  createWallet(options?: CreateWalletOptions): Promise<CreateWalletResult>
  setRecovery(options: SetRecoveryOptions): Promise<SetActiveWalletResult>
  exportPrivateKey(): Promise<string>
}
 
type WalletFlowFlags = {
  error?: OpenfortError
  isError: boolean
  isSuccess: boolean
  isCreating: boolean
  isConnecting: boolean
}
 
type UserWallet = {
  address: string // Hex string
  ownerAddress?: string
  implementationType?: string
  chainType: ChainTypeEnum
  isActive?: boolean
  isConnecting?: boolean
  getProvider(): Promise<OpenfortEmbeddedEthereumWalletProvider>
}
 
type SetActiveWalletResult = {
  error?: OpenfortError
  wallet?: UserWallet
  provider?: Provider
}
 
type CreateWalletResult = SetActiveWalletResult
 
type SetActiveWalletOptions = {
  address?: string
  chainId?: number
  recoveryPassword?: string
  onSuccess?: (data: SetActiveWalletResult) => void
  onError?: (error: OpenfortError) => void
  onSettled?: (data: SetActiveWalletResult | undefined | null, error: OpenfortError | null) => void
  throwOnError?: boolean
}
 
type CreateWalletOptions = {
  chainType?: ChainTypeEnum
  chainId?: number
  accountType?: AccountTypeEnum
  recoveryPassword?: string
  onSuccess?: (data: CreateWalletResult) => void
  onError?: (error: OpenfortError) => void
  onSettled?: (data: CreateWalletResult | undefined | null, error: OpenfortError | null) => void
  throwOnError?: boolean
}
 
type SetRecoveryOptions = {
  previousRecovery: RecoveryParams
  newRecovery: RecoveryParams
  onSuccess?: (data: SetActiveWalletResult) => void
  onError?: (error: OpenfortError) => void
  onSettled?: (data: SetActiveWalletResult | undefined | null, error: OpenfortError | null) => void
  throwOnError?: boolean
}
 
type RecoveryParams = {
  recoveryMethod: RecoveryMethod
  password?: string
  encryptionSession?: string
}
 
enum RecoveryMethod {
  AUTOMATIC = "automatic",
  PASSWORD = "password",
  PASSKEY = "passkey",
}
 
type OpenfortEmbeddedEthereumWalletProvider = {
  // EIP-1193 provider for interacting with the wallet
  request(args: { method: string; params?: any[] }): Promise<any>
}
 
type Provider = {
  // Provider type from openfort-js
  url: string
  chainId: number
}
 
enum ChainTypeEnum {
  EVM = "EVM",
  SVM = "SVM",
}
 
enum AccountTypeEnum {
  SMART_ACCOUNT = "Smart Account",
  EOA = "Externally Owned Account",
}

import { useWallets } from "@openfort/react-native"
 
function WalletManager() {
  const {
    wallets,
    activeWallet,
    setActiveWallet,
    setRecovery,
    createWallet,
    exportPrivateKey,
    isCreating,
    isConnecting,
    isError,
    error,
  } = useWallets({
    throwOnError: true,
    onSuccess: () => {},
    onError: () => {},
    onSettled: () => {}
  })
 
  const recover = (address: string) =>
    setActiveWallet({ address, recoveryPassword: 'example' })
 
  return null
}