Class Web3Connector

Class for MetaMask connection

Hierarchy

EventEmitter
- Web3Connector

Constructors

constructor

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

Properties

`Private` `Readonly`config

config: Web3Config

`Private`customProvider

customProvider: null | JsonRpcProvider = null

`Private`customWallet

customWallet: null | Wallet = null

`Private` `Readonly`DEFAULT_CONFIG

DEFAULT_CONFIG: Web3Config = ...

`Private` `Readonly`MESSAGE_TO_SIGN

MESSAGE_TO_SIGN: "I Love Shogun!"

`Private`provider

provider: null | BrowserProvider | JsonRpcProvider = 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<ISEAPair>
Generates credentials for the given address
Parameters
- address: string
Returns Promise<ISEAPair>

`Private`generateCredentialsFromSignature

generateCredentialsFromSignature(
address: string,
signature: string,
): Promise<ISEAPair>
Generates credentials from a signature
Parameters
- address: string
- signature: string
Returns Promise<ISEAPair>

`Private`generateFallbackCredentials

generateFallbackCredentials(address: string): Web3ConnectorCredentials
Generates fallback credentials (for testing/development)
Parameters
- address: string
Returns Web3ConnectorCredentials

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`getAvailableEthereumProvider

getAvailableEthereumProvider(): undefined | EthereumProvider
Get available Ethereum provider from multiple possible sources

Returns undefined | EthereumProvider

`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

getProvider

getProvider(): Promise<BrowserProvider | JsonRpcProvider>
Get active provider instance using BrowserProvider

Returns Promise<BrowserProvider | JsonRpcProvider>

getSigner

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

Returns Promise<Signer>

`Private`initProvider

initProvider(): void
Initialize the provider synchronously with fallback mechanisms to handle conflicts between multiple wallet providers

Returns void

isAvailable

isAvailable(): boolean
Checks if the connector 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>
Requests signature with timeout
Parameters
- address: string
- message: string
- timeout: number = 30000
Returns Promise<string>

setCustomProvider

setCustomProvider(rpcUrl: string, privateKey: string): void
Sets a custom provider for testing/development
Parameters
- rpcUrl: string
- privateKey: string
Returns void

`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

Returns boolean