Class WalletManager

Class that manages Ethereum wallet functionality including:

  • Wallet creation and derivation
  • Balance checking and transactions
  • Importing/exporting wallets
  • Encrypted storage and backup

Hierarchy

  • EventEmitter
    • WalletManager

Constructors

constructor

Properties

balanceCache config gun mainWallet pendingTransactions storage transactionMonitoringInterval walletPaths

Methods

checkPendingTransactions cleanup createAndLoadWallet createWallet decryptSensitiveData derivePrivateKeyFromMnemonic deriveWallet emit encryptSensitiveData exportAllUserData exportGunPair exportMnemonic exportWalletData exportWalletKeys generateNewMnemonic generatePrivateKeyFromString getBalance getMainWallet getNonce getProvider getStandardBIP44Addresses getStorageUserIdentifier getUserMasterMnemonic getUserMnemonic getWalletBalance getWalletHistory getWallets importAllUserData importGunPair importMnemonic importWalletData importWalletKeys initializeWalletPaths initWalletPathsSync invalidateBalanceCache isLogged isUserAuthenticated loadWalletPathsFromGun loadWalletPathsFromLocalStorage loadWallets off on once removeAllListeners resetMainWallet savePendingTransaction saveUserMasterMnemonic saveWalletPath saveWalletPathsToLocalStorage sendTransaction setBalanceCacheTTL setRpcUrl setupTransactionMonitoring signMessage signTransaction verifySignature

Constructors

constructor

  • new WalletManager(
        gun: any,
        storage: ShogunStorage,
        config?: Partial<WalletConfig>,
    ): WalletManager

    Creates a new WalletManager instance

    Parameters

    • gun: any

      Raw Gun instance

    • storage: ShogunStorage

      Storage interface for local persistence

    • Optionalconfig: Partial<WalletConfig>

      Additional configuration options

    Returns WalletManager

Properties

Private ReadonlybalanceCache

balanceCache: Map<string, BalanceCache> = ...

Private Readonlyconfig

config: WalletConfig

Private Readonlygun

gun: any

PrivatemainWallet

mainWallet: null | Wallet = null

Private ReadonlypendingTransactions

pendingTransactions: Map<string, TransactionResponse> = ...

Private Readonlystorage

storage: ShogunStorage

PrivatetransactionMonitoringInterval

transactionMonitoringInterval: null | Timeout = null

PrivatewalletPaths

walletPaths: { [address: string]: WalletPath } = {}

Methods

PrivatecheckPendingTransactions

  • checkPendingTransactions(): Promise<void>

    Check status of pending transactions

    Returns Promise<void>

cleanup

  • cleanup(): void

    Returns void

createAndLoadWallet

  • createAndLoadWallet(path: string): Promise<any>

    Crea e carica un wallet con un percorso specifico

    Parameters

    • path: string

      Percorso di derivazione

    Returns Promise<any>

    Informazioni sul wallet

createWallet

PrivatedecryptSensitiveData

  • decryptSensitiveData(encryptedText: string): Promise<null | string>

    Decrypt sensitive text encrypted with SEA

    Parameters

    • encryptedText: string

      Encrypted text

    Returns Promise<null | string>

    Decrypted text

PrivatederivePrivateKeyFromMnemonic

  • derivePrivateKeyFromMnemonic(mnemonic: string, path: string): HDNodeWallet
    Private

    Derives a private wallet from a mnemonic and derivation path

    Parameters

    • mnemonic: string

      The BIP-39 mnemonic phrase

    • path: string

      The derivation path

    Returns HDNodeWallet

    A derived HDNodeWallet instance

deriveWallet

  • deriveWallet(path: string): Promise<Wallet>

    Deriva un wallet da un percorso derivazione

    Parameters

    • path: string

      Percorso di derivazione BIP-44 (es: m/44'/60'/0'/0/0)

    Returns Promise<Wallet>

    Wallet derivato

emit

  • emit(event: EventType, data?: unknown): boolean

    Emits an event with arguments

    Parameters

    • event: EventType
    • Optionaldata: unknown

    Returns boolean

PrivateencryptSensitiveData

  • encryptSensitiveData(text: string): Promise<string>

    Encrypt sensitive text using SEA

    Parameters

    • text: string

      Text to encrypt

    Returns Promise<string>

    Encrypted text

exportAllUserData

  • exportAllUserData(password: string): Promise<string>

    Esporta tutti i dati dell'utente in un unico file

    Parameters

    • password: string

      Password obbligatoria per cifrare i dati esportati

    Returns Promise<string>

    Un oggetto JSON contenente tutti i dati dell'utente

exportGunPair

  • exportGunPair(password?: string): Promise<string>

    Export GunDB pair, optionally encrypted with a password

    Parameters

    • Optionalpassword: string

      Optional password to encrypt the exported data

    Returns Promise<string>

    Exported GunDB pair (SENSITIVE DATA!) SECURITY WARNING: This method exports your GunDB credentials which give access to your encrypted data. Never share this data with anyone, store it securely, and only use it for backup purposes.

exportMnemonic

  • exportMnemonic(password?: string): Promise<string>

    Export the mnemonic phrase, optionally encrypting it with a password

    Parameters

    • Optionalpassword: string

      Optional password to encrypt the exported data

    Returns Promise<string>

    Exported mnemonic phrase (SENSITIVE DATA!) SECURITY WARNING: This method exports your mnemonic phrase which gives FULL ACCESS to all your wallets. Never share this data with anyone, store it securely, and only use it for backup purposes.

exportWalletData

  • exportWalletData(options?: WalletBackupOptions): Promise<string>

    Export wallet data with enhanced security

    Parameters

    • options: WalletBackupOptions = {}

    Returns Promise<string>

exportWalletKeys

  • exportWalletKeys(password?: string): Promise<string>

    Export wallet private keys, optionally encrypted with a password

    Parameters

    • Optionalpassword: string

      Optional password to encrypt the exported data

    Returns Promise<string>

    Exported wallet keys (SENSITIVE DATA!) SECURITY WARNING: This method exports your wallet private keys which give FULL ACCESS to your funds. Never share this data with anyone, store it securely, and only use it for backup purposes.

generateNewMnemonic

  • generateNewMnemonic(): string

    Generate a new BIP-39 standard mnemonic compatible with all wallets

    Returns string

    A new 12-word BIP-39 mnemonic phrase

PrivategeneratePrivateKeyFromString

  • generatePrivateKeyFromString(input: string): string

    Override of main function with fixes and improvements

    Parameters

    • input: string

    Returns string

getBalance

  • getBalance(wallet: Wallet): Promise<string>

    Get wallet balance with caching to reduce RPC calls

    Parameters

    • wallet: Wallet

    Returns Promise<string>

getMainWallet

  • getMainWallet(): Wallet

    Get the main wallet

    Returns Wallet

getNonce

  • getNonce(wallet: Wallet): Promise<number>

    Parameters

    • wallet: Wallet

    Returns Promise<number>

getProvider

  • getProvider(): JsonRpcProvider

    Gets a configured JSON RPC provider instance

    Returns JsonRpcProvider

    An ethers.js JsonRpcProvider instance

getStandardBIP44Addresses

  • getStandardBIP44Addresses(mnemonic: string, count?: number): string[]

    Get addresses that would be derived from a mnemonic using BIP-44 standard This is useful to verify that wallets are correctly compatible with MetaMask and other wallets

    Parameters

    • mnemonic: string

      The BIP-39 mnemonic phrase

    • count: number = 5

      Number of addresses to derive

    Returns string[]

    An array of Ethereum addresses

PrivategetStorageUserIdentifier

  • getStorageUserIdentifier(): string
    Private

    Gets a unique identifier for the current user for storage purposes

    Returns string

    A string identifier based on user's public key or "guest"

getUserMasterMnemonic

  • getUserMasterMnemonic(): Promise<null | string>

    Get user's master mnemonic, first checking GunDB then localStorage

    Returns Promise<null | string>

getUserMnemonic

  • getUserMnemonic(): Promise<null | string>

    Ottiene il mnemonic dell'utente

    Returns Promise<null | string>

    Mnemonic dell'utente

getWalletBalance

  • getWalletBalance(): Promise<string>

    Ottiene il saldo del wallet principale

    Returns Promise<string>

    Saldo formattato come stringa

PrivategetWalletHistory

  • getWalletHistory(): Promise<any[]>

    Get wallet transaction history

    Returns Promise<any[]>

getWallets

  • getWallets(): Promise<any[]>

    Ottiene tutti i wallet dell'utente

    Returns Promise<any[]>

    Array di wallet

importAllUserData

  • importAllUserData(
        backupData: string,
        password: string,
        options?: {
            importGunPair?: boolean;
            importMnemonic?: boolean;
            importWallets?: boolean;
        },
    ): Promise<
        {
            gunPairImported?: boolean;
            mnemonicImported?: boolean;
            success: boolean;
            walletsImported?: number;
        },
    >

    Importa un backup completo

    Parameters

    • backupData: string

      JSON cifrato contenente tutti i dati dell'utente

    • password: string

      Password per decifrare il backup

    • options: { importGunPair?: boolean; importMnemonic?: boolean; importWallets?: boolean } = ...

      Opzioni di importazione (quali dati importare)

    Returns Promise<
        {
            gunPairImported?: boolean;
            mnemonicImported?: boolean;
            success: boolean;
            walletsImported?: number;
        },
    >

    Un oggetto con il risultato dell'importazione

importGunPair

  • importGunPair(pairData: string, password?: string): Promise<boolean>

    Importa un pair di Gun

    Parameters

    • pairData: string

      JSON contenente il pair di Gun o JSON cifrato

    • Optionalpassword: string

      Password opzionale per decifrare i dati se cifrati

    Returns Promise<boolean>

    true se l'importazione è riuscita

importMnemonic

  • importMnemonic(mnemonicData: string, password?: string): Promise<boolean>

    Importa una frase mnemonica

    Parameters

    • mnemonicData: string

      La mnemonica o il JSON cifrato da importare

    • Optionalpassword: string

      Password opzionale per decifrare la mnemonica se cifrata

    Returns Promise<boolean>

    true se l'importazione è riuscita

importWalletData

  • importWalletData(data: string, options?: WalletImportOptions): Promise<number>

    Import wallet data with validation

    Parameters

    • data: string
    • options: WalletImportOptions = {}

    Returns Promise<number>

importWalletKeys

  • importWalletKeys(walletsData: string, password?: string): Promise<number>

    Importa le chiavi private dei wallet

    Parameters

    • walletsData: string

      JSON contenente i dati dei wallet o JSON cifrato

    • Optionalpassword: string

      Password opzionale per decifrare i dati se cifrati

    Returns Promise<number>

    Il numero di wallet importati con successo

initializeWalletPaths

  • initializeWalletPaths(): Promise<void>

    Initializes wallet paths from both GunDB and localStorage Call this method explicitly when needed

    Returns Promise<void>

    Throws

    If there's an error during wallet path initialization

PrivateinitWalletPathsSync

  • initWalletPathsSync(): void
    Private

    Initialize wallet paths synchronously with basic setup

    Returns void

invalidateBalanceCache

  • invalidateBalanceCache(address: string): void

    Invalidate balance cache for an address

    Parameters

    • address: string

    Returns void

isLogged

  • isLogged(): boolean

    Verifica se l'utente è loggato

    Returns boolean

    true se l'utente è loggato, false altrimenti

PrivateisUserAuthenticated

  • isUserAuthenticated(): boolean
    Private

    Verifica se l'utente è autenticato

    Returns boolean

    true se l'utente è autenticato

PrivateloadWalletPathsFromGun

  • loadWalletPathsFromGun(): Promise<void>
    Private

    Loads wallet paths from GunDB

    Returns Promise<void>

PrivateloadWalletPathsFromLocalStorage

  • loadWalletPathsFromLocalStorage(): void
    Private

    Loads wallet paths from localStorage as backup

    Returns void

loadWallets

off

  • off(event: EventType, listener: (data: unknown) => void): void

    Removes an event listener

    Parameters

    • event: EventType
    • listener: (data: unknown) => void

    Returns void

on

  • on(event: EventType, listener: (data: unknown) => void): void

    Registers an event listener

    Parameters

    • event: EventType
    • listener: (data: unknown) => void

    Returns void

once

  • once(event: EventType, listener: (data: unknown) => void): void

    Registers a one-time event listener

    Parameters

    • event: EventType
    • listener: (data: unknown) => void

    Returns void

removeAllListeners

  • removeAllListeners(event?: EventType): void

    Removes all listeners for an event or all events

    Parameters

    • Optionalevent: EventType

    Returns void

resetMainWallet

  • resetMainWallet(): void

    Reset main wallet Useful when we want to force wallet regeneration

    Returns void

savePendingTransaction

  • savePendingTransaction(tx: any): Promise<void>

    Salva una transazione pendente

    Parameters

    • tx: any

      Transazione da salvare

    Returns Promise<void>

saveUserMasterMnemonic

  • saveUserMasterMnemonic(mnemonic: string): Promise<void>

    Save user's master mnemonic to both GunDB and localStorage

    Parameters

    • mnemonic: string

    Returns Promise<void>

saveWalletPath

  • saveWalletPath(address: string, path: string): Promise<void>

    Salva il percorso di derivazione di un wallet

    Parameters

    • address: string

      Indirizzo del wallet

    • path: string

      Percorso di derivazione

    Returns Promise<void>

PrivatesaveWalletPathsToLocalStorage

  • saveWalletPathsToLocalStorage(): void
    Private

    Saves wallet paths to localStorage for backup

    Returns void

sendTransaction

  • sendTransaction(
        wallet: Wallet,
        toAddress: string,
        value: string,
        options?: TransactionOptions,
    ): Promise<string>

    Parameters

    • wallet: Wallet
    • toAddress: string
    • value: string
    • options: TransactionOptions = {}

    Returns Promise<string>

setBalanceCacheTTL

  • setBalanceCacheTTL(ttlMs: number): void

    Update the balance cache TTL

    Parameters

    • ttlMs: number

      Time-to-live in milliseconds

    Returns void

setRpcUrl

  • setRpcUrl(rpcUrl: string): void

    Sets the RPC URL used for Ethereum network connections

    Parameters

    • rpcUrl: string

      The RPC provider URL to use

    Returns void

PrivatesetupTransactionMonitoring

  • setupTransactionMonitoring(): void

    Setup transaction monitoring

    Returns void

signMessage

  • signMessage(
        wallet: Wallet,
        message: string | Uint8Array<ArrayBufferLike>,
    ): Promise<string>

    Sign a message with a wallet

    Parameters

    • wallet: Wallet
    • message: string | Uint8Array<ArrayBufferLike>

    Returns Promise<string>

signTransaction

  • signTransaction(
        wallet: Wallet,
        toAddress: string,
        value: string,
        provider?: JsonRpcProvider,
    ): Promise<string>

    Sign a transaction

    Parameters

    • wallet: Wallet
    • toAddress: string
    • value: string
    • Optionalprovider: JsonRpcProvider

    Returns Promise<string>

verifySignature

  • verifySignature(
        message: string | Uint8Array<ArrayBufferLike>,
        signature: string,
    ): string

    Verify a signature

    Parameters

    • message: string | Uint8Array<ArrayBufferLike>
    • signature: string

    Returns string

Settings

Member Visibility

On This Page

Constructors
Properties
Methods
checkPendingTransactionscleanupcreateAndLoadWalletcreateWalletdecryptSensitiveDataderivePrivateKeyFromMnemonicderiveWalletemitencryptSensitiveDataexportAllUserDataexportGunPairexportMnemonicexportWalletDataexportWalletKeysgenerateNewMnemonicgeneratePrivateKeyFromStringgetBalancegetMainWalletgetNoncegetProvidergetStandardBIP44AddressesgetStorageUserIdentifiergetUserMasterMnemonicgetUserMnemonicgetWalletBalancegetWalletHistorygetWalletsimportAllUserDataimportGunPairimportMnemonicimportWalletDataimportWalletKeysinitializeWalletPathsinitWalletPathsSyncinvalidateBalanceCacheisLoggedisUserAuthenticatedloadWalletPathsFromGunloadWalletPathsFromLocalStorageloadWalletsoffononceremoveAllListenersresetMainWalletsavePendingTransactionsaveUserMasterMnemonicsaveWalletPathsaveWalletPathsToLocalStoragesendTransactionsetBalanceCacheTTLsetRpcUrlsetupTransactionMonitoringsignMessagesignTransactionverifySignature