MagicLink

Auto connect wallet if the user is already logged in.

function autoConnect(
  options?: MagicAuthConnectOptions,
): Promise<string>;

let options: MagicAuthConnectOptions;

let returnType: Promise<string>;

Connect Wallet using Magic Auth or Magic Connect

There are three ways to call the connect function - email or phoneNumber or oauthProvider

This opens the Magic Link's Modal and prompts the user to click on the link sent to their email.

await wallet.connect({
  email: "user@example.com",
});

This opens the Magic Link's Modal and prompts the user to enter the OTP sent to their phone via SMS.

await wallet.connect({
  phoneNumber: "+123456789",
});

This redirects the user to given provider's sign-in page and once the user is authenticated, it redirects the user back to the redirectURI provided in MagicLink constructor.

await magic.connect({
  oauthProvider: "google",
});

wallet.connect({
  chainId: 5,
});

If chainId is provided, the wallet will be connected to the network with the given chainId, else it will be connected to the Ethereum Mainnet.

You can call the connect function without any arguments. Calling connect opens the Magic Link's Modal and prompts the user to login via Google or email.

await wallet.connect();

wallet.connect({
  chainId: 5,
});

If chainId is provided, the wallet will be connected to the network with the given chainId, else it will be connected to the Ethereum Mainnet.

function connect(options: MagicAuthConnectOptions): Promise<string>;

let options: MagicAuthConnectOptions;

let returnType: Promise<string>;

Disconnect wallet

function disconnect(): Promise<void>;

let returnType: Promise<void>;

Get Magic Auth SDK instance. Learn more about Magic Auth SDK

you use all methods available in the Magic Auth SDK from the SDK instance. Refer to Magic Auth API for more details.

const magicSDK = await wallet.getMagic();

function getMagic(): InstanceWithExtensions<
  SDKBase,
  Array<OAuthExtension>
>;

let returnType: InstanceWithExtensions<
  SDKBase,
  Array<OAuthExtension>
>;

Calls each of the listeners registered for a given event.

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

let event: T;

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

let returnType: boolean;

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

function eventNames(): Array<keyof WalletEvents>;

let returnType: Array<keyof WalletEvents>;

Returns the account address of the connected wallet

function getAddress(): Promise<string>;

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;
}>;

let tokenAddress: string;

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>;

let returnType: Promise<number>;

If the wallet uses another "personal wallet" under the hood, return it

This is only useful for wallets like Safe or Smart Wallet uses a "personal wallet" under the hood to sign transactions. This method returns that wallet

function getPersonalWallet(): undefined | EVMWallet;

let returnType: undefined | EVMWallet;

Get ethers Signer object of the connected wallet

function getSigner(): Promise<Signer>;

let returnType: Promise<Signer>;

Return the number of listeners listening to a given event.

function listenerCount(event: keyof WalletEvents): number;

let event: keyof WalletEvents;

let returnType: number;

Return the listeners registered for a given event.

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

let event: T;

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

Add a listener for a given event.

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

let event: T;

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

let context: any;

let returnType: this;

Add a one-time listener for a given event.

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

let event: T;

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

let context: any;

let returnType: this;

Remove all listeners, or those of the specified event.

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

let event: keyof WalletEvents;

let returnType: this;

Remove the listeners of a given event.

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

let event: T;

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

let context: any;

let once: boolean;

let returnType: this;

Sign a message with the connected wallet and return the signature

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

let message: string | Bytes;

let returnType: Promise<string>;

Switch to different Network/Blockchain in the connected wallet

function switchChain(chainId: number): Promise<void>;

let chainId: number;

let returnType: Promise<void>;

Transfers some amount of tokens to the specified address

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

let to: string;

let amount: string | number;

let currencyAddress: string;

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

Update the chains supported by the wallet. This is useful if wallet was initialized with some chains and this needs to be updated without re-initializing the wallet

function updateChains(chains: Array<Chain>): Promise<void>;

let chains: Array<Chain>;

let returnType: Promise<void>;

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>;

let message: string;

let signature: string;

let address: string;

let _chainId: number;

let returnType: Promise<boolean>;