Class MetaMask

Class for MetaMask connection

Hierarchy

EventEmitter
- MetaMask

Constructors

constructor

new MetaMask(config?: Partial<MetaMaskConfig>): MetaMask
Parameters
- config: Partial<MetaMaskConfig> = {}
Returns MetaMask
Overrides EventEmitter.constructor

Properties

`Readonly`AUTH_DATA_TABLE

AUTH_DATA_TABLE: string

`Private` `Readonly`config

config: MetaMaskConfig

`Private`customProvider

customProvider: null | JsonRpcProvider = null

`Private`customWallet

customWallet: null | Wallet = null

`Private` `Readonly`DEFAULT_CONFIG

DEFAULT_CONFIG: MetaMaskConfig = ...

`Private` `Readonly`MESSAGE_TO_SIGN

MESSAGE_TO_SIGN: "I Love Shogun!"

`Private`provider

provider: null | BrowserProvider = null

`Private` `Readonly`signatureCache

signatureCache: Map<string, SignatureCache> = ...

Methods

`Private`cacheSignature

cacheSignature(address: string, signature: string): void
Cache signature
Parameters
- address: string
- signature: string
Returns void

cleanup

cleanup(): void
Cleanup event listeners

Returns void

connectMetaMask

connectMetaMask(): Promise<ConnectionResult>
Connects to MetaMask with retry logic using BrowserProvider

Returns Promise<ConnectionResult>

emit

emit(event: EventType, data?: unknown): boolean
Emits an event with arguments
Parameters
- event: EventType
- Optionaldata: unknown
Returns boolean
Inherited from EventEmitter.emit

generateCredentials

generateCredentials(address: string): Promise<MetaMaskCredentials>
Generates credentials with caching
Parameters
- address: string
Returns Promise<MetaMaskCredentials>

`Private`generateCredentialsFromSignature

generateCredentialsFromSignature(
address: string,
signature: string,
): MetaMaskCredentials
Generate credentials from signature
Parameters
- address: string
- signature: string
Returns MetaMaskCredentials

`Private`generateFallbackCredentials

generateFallbackCredentials(address: string): MetaMaskCredentials
Generate fallback credentials when signature request fails Questo è meno sicuro della firma, ma permette di procedere con l'autenticazione
Parameters
- address: string
Returns MetaMaskCredentials

generatePassword

generatePassword(signature: string): Promise<string>
Generate deterministic password from signature
Parameters
- signature: string
  Cryptographic signature
Returns Promise<string>
64-character hex string

Throws
For invalid signature

`Private`getCachedSignature

getCachedSignature(address: string): null | string
Get cached signature if valid
Parameters
- address: string
Returns null | string

getEthereumSigner

getEthereumSigner(): Promise<Signer>
Get browser-based Ethereum signer

Returns Promise<Signer>
Browser provider signer

Throws
If MetaMask not detected

getSigner

getSigner(): Promise<Signer>
Get active signer instance using BrowserProvider

Returns Promise<Signer>

`Private`initProvider

initProvider(): void
Initialize the provider synchronously

Returns void

isAvailable

isAvailable(): boolean
Checks if MetaMask is available

Returns boolean

off

off(event: EventType, listener: (data: unknown) => void): void
Removes an event listener
Parameters
- event: EventType
- listener: (data: unknown) => void
Returns void
Inherited from EventEmitter.off

on

on(event: EventType, listener: (data: unknown) => void): void
Registers an event listener
Parameters
- event: EventType
- listener: (data: unknown) => void
Returns void
Inherited from EventEmitter.on

once

once(event: EventType, listener: (data: unknown) => void): void
Registers a one-time event listener
Parameters
- event: EventType
- listener: (data: unknown) => void
Returns void
Inherited from EventEmitter.once

removeAllListeners

removeAllListeners(event?: EventType): void
Removes all listeners for an event or all events
Parameters
- Optionalevent: EventType
Returns void
Inherited from EventEmitter.removeAllListeners

`Private`requestSignatureWithTimeout

requestSignatureWithTimeout(
    address: string,
    message: string,
    timeout?: number,
): Promise<string>
Request signature using BrowserProvider
Parameters
- address: string
- message: string
- timeout: number = 30000
Returns Promise<string>

setCustomProvider

setCustomProvider(rpcUrl: string, privateKey: string): void
Configure custom JSON-RPC provider
Parameters
- rpcUrl: string
  RPC endpoint URL
- privateKey: string
  Wallet private key
Returns void
Throws
For invalid parameters

`Private`setupEventListeners

setupEventListeners(): void
Setup MetaMask event listeners using BrowserProvider

Returns void

setupProvider

setupProvider(): Promise<void>
Initialize the BrowserProvider (async method for explicit calls)

Returns Promise<void>

`Private`validateAddress

validateAddress(address: undefined | null | string): string
Validates that the address is valid
Parameters
- address: undefined | null | string
Returns string

verifySignature

verifySignature(message: string, signature: string): Promise<string>
Verify message signature
Parameters
- message: string
  Original signed message
- signature: string
  Cryptographic signature
Returns Promise<string>
Recovered Ethereum address

Throws
For invalid inputs

`Static`isMetaMaskAvailable

isMetaMaskAvailable(): boolean
Checks if MetaMask is available in the browser

Returns boolean
true if MetaMask is available