EmbeddedWallet

Authenticate the user with any of the available auth strategies.

const authResult = await wallet.authenticate({
  strategy: "google",
});

function authenticate(params: AuthParams): Promise<AuthResult>;

// email verification
type EmailVerificationAuthParams = {
  strategy: "email_verification";
  email: string;
  verificationCode: string;
  recoveryCode?: string;
};
 
export type EmbeddedWalletOauthStrategy =
  | "google"
  | "apple"
  | "facebook";
 
type OauthAuthParams = {
  strategy: EmbeddedWalletOauthStrategy;
  openedWindow?: Window;
  closeOpenedWindow?: (window: Window) => void;
};
 
// bring your own authentication
type JwtAuthParams = {
  strategy: "jwt";
  jwt: string;
  encryptionKey?: string;
};
 
// open iframe to send and input the verification code only
type IframeOtpAuthParams = {
  strategy: "iframe_email_verification";
  email: string;
};
 
// open iframe to enter email and verification code
type IframeAuthParams = {
  strategy: "iframe";
};

let params: AuthParams;

let returnType: Promise<AuthResult>;

const authResult = await wallet.authenticate(authOptions);
await wallet.connect({ authResult });

auto connect the wallet if the wallet was previously connected and session is still valid

function autoConnect(
  connectOptions?: ConnectParams<EmbeddedWalletConnectionArgs>,
): Promise<string>;

let connectOptions: ConnectParams<EmbeddedWalletConnectionArgs>;

let returnType: Promise<string>;

After authenticating, you can connect to the wallet by passing the authResult to the connect method.

const authResult = await wallet.authenticate(authOptions);
 
await wallet.connect({ authResult });

function connect(
  connectOptions?: ConnectParams<EmbeddedWalletConnectionArgs>,
): Promise<string>;

let connectOptions: ConnectParams<EmbeddedWalletConnectionArgs>;

let returnType: Promise<string>;

Get the email associated with the currently connected wallet.

```javascript
const email = await wallet.getEmail();

function getEmail(): Promise<undefined | string>;

let returnType: Promise<undefined | string>;

Get the instance of EmbeddedWalletSdk used by the wallet.

function getEmbeddedWalletSDK(): Promise<EmbeddedWalletSdk>;

let returnType: Promise<EmbeddedWalletSdk>;

Get the phone number associated with the currently connected wallet.

```javascript
const email = await wallet.getPhoneNumber();

function getPhoneNumber(): Promise<undefined | string>;

let returnType: Promise<undefined | string>;

Send a verification code to the user's email for verification. Use this as a prestep before calling authenticate with the email_verification strategy.

const result = await wallet.sendVerificationEmail({
  email: "alice@example.com",
});

This method is also available as a static method on the EmbeddedWallet class.

const result = await EmbeddedWallet.sendVerificationEmail({
  email: "alice@example.com",
});

function sendVerificationEmail(options: {
  email: string;
}): Promise<SendEmailOtpReturnType>;

let options: { email: string };

let returnType: Promise<SendEmailOtpReturnType>;

{
  isNewDevice: boolean;
  isNewUser: boolean;
  recoveryShareManagement: "USER_MANAGED" | "AWS_MANAGED";
}

Send a verification code to the user's phone number for verification. The phone number must contain the country code. Use this as a pre-step before calling authenticate with the phone_number_verification strategy.

const result = await wallet.sendVerificationSms({
  phoneNumber: "+1234567890",
});

This method is also available as a static method on the EmbeddedWallet class.

const result = await EmbeddedWallet.sendVerificationSms({
  phoneNumber: "+1234567890",
});

function sendVerificationSms(options: {
  phoneNumber: string;
}): Promise<SendEmailOtpReturnType>;

let options: { phoneNumber: string };

let returnType: Promise<SendEmailOtpReturnType>;

{
  isNewDevice: boolean;
  isNewUser: boolean;
  recoveryShareManagement: "USER_MANAGED" | "AWS_MANAGED";
}

Sends a verification email to the provided email address.

EmbeddedWallet.sendVerificationEmail({
  email: "test@example.com",
  clientId: "yourClientId",
})
  .then(() => console.log("Verification email sent successfully."))
  .catch((error) =>
    console.error("Failed to send verification email:", error),
  );

function sendVerificationEmail(options: {
  clientId: string;
  email: string;
}): Promise<SendEmailOtpReturnType>;

let options: { clientId: string; email: string };

let returnType: Promise<SendEmailOtpReturnType>;

Sends a verification sms to the provider phone number.

const result = await EmbeddedWallet.sendVerificationEmail({
  phoneNumber: "+1234567890",
  clientId: "yourClientId",
});

function sendVerificationSms(options: {
  clientId: string;
  phoneNumber: string;
}): Promise<SendEmailOtpReturnType>;

let options: { clientId: string; phoneNumber: string };

let returnType: Promise<SendEmailOtpReturnType>;

Disconnect the wallet

function disconnect(): Promise<void>;

let returnType: Promise<void>;

Calls each of the listeners registered for a given event.

function emit(
  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(
  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(
  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(
  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(
  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>;