References
AbstractWallet

AbstractWallet

The base class for any wallet in the Wallet SDK, including backend wallets. It contains the functionality common to all wallets.

This wallet is not meant to be used directly, but instead be extended to build your own wallet


class AbstractWallet
  extends EventEmitter<WalletEvents>
  implements GenericAuthWallet, EVMWallet {}

Inherited from EventEmitter<WalletEvents>.constructor


function constructor(): AbstractWallet;

Returns


let returnType: AbstractWallet;

Methods

Returns the account address of the connected wallet


function getAddress(): Promise<string>;

Returns


let returnType: Promise<string>;

Returns the balance of the connected wallet for the specified token address. If no token address is specified, it returns the balance of the native token


function getBalance(
  tokenAddress: string,
): Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

Parameters

The contract address of the token

Type


let tokenAddress: string;

Returns


let returnType: Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

Returns the chain id of the network that the wallet is connected to


function getChainId(): Promise<number>;

Returns


let returnType: Promise<number>;

Returns an ethers Signer object of the connected wallet


function getSigner(): Promise<Signer>;

Returns


let returnType: Promise<Signer>;

Sign a message with the connected wallet and return the signature


function signMessage(message: string | Bytes): Promise<string>;

Parameters

The message to sign

Type


let message: string | Bytes;

Returns


let returnType: Promise<string>;

The signature

Transfers some amount of tokens to the specified address


function transfer(
  to: string,
  amount: string | number,
  currencyAddress: string,
): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>;

Parameters

The address to transfer the amount to

Type


let to: string;

The amount to transfer

Type


let amount: string | number;

The contract address of the token to transfer. If not specified, it defaults to the native token

Type


let currencyAddress: string;

Returns


let returnType: Promise<
  Omit<TransactionResultWithMetadata<unknown>, "data">
>;

The transaction result

Verify the signature of a message. It returns true if the signature is valid, false otherwise


function verifySignature(
  message: string,
  signature: string,
  address: string,
  _chainId?: number,
): Promise<boolean>;

Parameters

The message to verify

Type


let message: string;

The signature to verify

Type


let signature: string;

The address to verify the signature against

Type


let address: string;

Type


let _chainId: number;

Returns


let returnType: Promise<boolean>;

Inherited Methods

Inherited from EventEmitter.addListener


function addListener(
  event: T,
  fn: (
    ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
  ) => void,
  context?: any,
): this;

Parameters

Type


let event: T;

Type


let fn: (
  ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
) => void;

Type


let context: any;

Returns


let returnType: this;

Inherited from EventEmitter.emit

Calls each of the listeners registered for a given event.


function emit(
  event: T,
  ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
): boolean;

Parameters

Type


let event: T;

Type


let args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>];

Returns


let returnType: boolean;

Inherited from EventEmitter.eventNames

Return an array listing the events for which the emitter has registered listeners.


function eventNames(): Array<keyof WalletEvents>;

Returns


let returnType: Array<keyof WalletEvents>;

Inherited from EventEmitter.listenerCount

Return the number of listeners listening to a given event.


function listenerCount(event: keyof WalletEvents): number;

Parameters

Type


let event: keyof WalletEvents;

Returns


let returnType: number;

Inherited from EventEmitter.listeners

Return the listeners registered for a given event.


function listeners(
  event: T,
): Array<
  (
    ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
  ) => void
>;

Parameters

Type


let event: T;

Returns


let returnType: Array<
  (
    ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
  ) => void
>;

Inherited from EventEmitter.off


function off(
  event: T,
  fn?: (
    ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
  ) => void,
  context?: any,
  once?: boolean,
): this;

Parameters

Type


let event: T;

Type


let fn: (
  ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
) => void;

Type


let context: any;

Type


let once: boolean;

Returns


let returnType: this;

Inherited from EventEmitter.on

Add a listener for a given event.


function on(
  event: T,
  fn: (
    ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
  ) => void,
  context?: any,
): this;

Parameters

Type


let event: T;

Type


let fn: (
  ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
) => void;

Type


let context: any;

Returns


let returnType: this;

Inherited from EventEmitter.once

Add a one-time listener for a given event.


function once(
  event: T,
  fn: (
    ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
  ) => void,
  context?: any,
): this;

Parameters

Type


let event: T;

Type


let fn: (
  ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
) => void;

Type


let context: any;

Returns


let returnType: this;

Inherited from EventEmitter.removeAllListeners

Remove all listeners, or those of the specified event.


function removeAllListeners(event?: keyof WalletEvents): this;

Parameters

Type


let event: keyof WalletEvents;

Returns


let returnType: this;

Inherited from EventEmitter.removeListener

Remove the listeners of a given event.


function removeListener(
  event: T,
  fn?: (
    ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
  ) => void,
  context?: any,
  once?: boolean,
): this;

Parameters

Type


let event: T;

Type


let fn: (
  ...args: ArgumentMap<WalletEvents>[Extract<T, keyof WalletEvents>]
) => void;

Type


let context: any;

Type


let once: boolean;

Returns


let returnType: this;

Properties


let prefixed: string | boolean;

Was this page helpful?

Need help?
Visit our support site
Watch our
Video Tutorials
View our
Changelog

Subscribe for the latest dev updates

AbstractWallet

Signature

Constructor

Signature

Returns

Return Type

Methods

getAddress

Signature

Returns

Return Type

getBalance

Signature

Parameters

tokenAddress

Type

Returns

Return Type

getChainId

Signature

Returns

Return Type

getSigner

Signature

Returns

Return Type

signMessage

Signature

Parameters

message

Type

Returns

Return Type

transfer

Signature

Parameters

to

Type

amount

Type

currencyAddress

Type

Returns

Return Type

verifySignature

Signature

Parameters

message

Type

signature

Type

address

Type

_chainId

Type

Returns

Return Type

Inherited Methods

addListener

Signature

Parameters

event

Type

fn

Type

context

Type

Returns

Return Type

emit

Signature

Parameters

event

Type

args

Type

Returns

Return Type

eventNames

Signature