AlchemyWebSigner

params

{ client: | AlchemySignerWebClient | { connection: | { apiKey: string; jwt?: undefined; rpcUrl?: undefined; } | { apiKey?: undefined; jwt: string; rpcUrl?: undefined; } | { apiKey?: undefined; jwt?: undefined; rpcUrl: string; } | { apiKey?: undefined; jwt: string; rpcUrl: string; } & object; enablePopupOauth?: boolean; iframeConfig: { iframeContainerId: string; iframeElementId?: string; }; oauthCallbackUrl?: string; rootOrgId?: string; rpId?: string; }; sessionConfig?: { expirationTimeMs?: number; sessionKey?: string; storage?: "localStorage" | "sessionStorage" | Storage; }; }

The parameters for the Alchemy signer, including the client and session configuration

params.client

| AlchemySignerWebClient | { connection: | { apiKey: string; jwt?: undefined; rpcUrl?: undefined; } | { apiKey?: undefined; jwt: string; rpcUrl?: undefined; } | { apiKey?: undefined; jwt?: undefined; rpcUrl: string; } | { apiKey?: undefined; jwt: string; rpcUrl: string; } & object; enablePopupOauth?: boolean; iframeConfig: { iframeContainerId: string; iframeElementId?: string; }; oauthCallbackUrl?: string; rootOrgId?: string; rpId?: string; }

‐

params.sessionConfig?

{ expirationTimeMs?: number; sessionKey?: string; storage?: "localStorage" | "sessionStorage" | Storage; }

‐

params.sessionConfig.expirationTimeMs?

number

‐

params.sessionConfig.sessionKey?

string

‐

params.sessionConfig.storage?

"localStorage" | "sessionStorage" | Storage

‐

addMfa

(params) => Promise<AddMfaResult>

undefined

Initiates the setup of a new MFA factor for the current user. The factor will need to be verified using verifyMfa before it becomes active.

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const result = await signer.addMfa({ multiFactorType: "totp" });
15
// Result contains multiFactorTotpUrl to display as QR code

Throws

If no user is authenticated

addPasskey

(params?) => Promise<string[]>

undefined

Adds a passkey to the user’s account

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const result = await signer.addPasskey()

authenticate

(params) => Promise<User>

undefined

Authenticate a user with either an email or a passkey and create a session for that user

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const result = await signer.authenticate({
15
 type: "email",
16
 email: "[email protected]",
17
});

disconnect

() => Promise<void>

undefined

Clear a user session and log them out

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
await signer.disconnect();

exportWallet

(config) => Promise<boolean>

undefined

Used to export the wallet for a given user If the user is authenticated with an Email, this will return a seed phrase If the user is authenticated with a Passkey, this will return a private key

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
// the params passed to this are different based on the specific signer
15
const result = signer.exportWallet()

Param

exportWallet parameters

getAddress

() => Promise<`0x${string}`>

undefined

Retrieves the address of the current user by calling the whoami method on this.inner.

getMfaFactors

() => Promise<{ multiFactors: MfaFactor[]; }>

undefined

Retrieves the list of MFA factors configured for the current user.

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const { multiFactors } = await signer.getMfaFactors();

Throws

If no user is authenticated

getPasskeyStatus

() => Promise<{ isPasskeyAdded: boolean; }>

undefined

‐

inner

AlchemySignerWebClient

undefined

‐

removeEmail

() => Promise<void>

undefined

Removes the email for the authenticated user, disallowing them from login with that email.

Throws

If the user is not authenticated

removeMfa

(params) => Promise<{ multiFactors: MfaFactor[]; }>

undefined

Removes existing MFA factors by their IDs.

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const result = await signer.removeMfa({
15
  multiFactorIds: ["factor-id-1", "factor-id-2"]
16
});

Throws

If no user is authenticated

removePasskey

(authenticatorId) => Promise<void>

undefined

Removes a passkey from a user’s account

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const authMethods = await signer.listAuthMethods();
15
const passkey = authMethods.passkeys[0];
16
17
const result = await signer.removePasskey(passkey.authenticatorId);

removePhoneNumber

() => Promise<void>

undefined

Removes the phone number for the authenticated user, disallowing them from login with that phone number.

Throws

If the user is not authenticated

sendVerificationCode

(type, contact) => Promise<{ otpId: string; }>

undefined

Initiates an OTP (One-Time Password) verification process for a user contact. Use this method before calling setEmail with verification code to verify ownership of the email address.

Throws

If the user is not authenticated

setPhoneNumber

(params) => Promise<void>

undefined

Sets the phone number for the authenticated user, allowing them to login with that phone number. sendVerificationCode should be called first to obtain the code.

Throws

If the user is not authenticated

signAuthorization

(unsignedAuthorization) => Promise<SignedAuthorization<number>>

undefined

Signs an EIP-7702 Authorization and then returns the authorization with the signature.

Example

import { 
class AlchemyWebSigner
A SmartAccountSigner that can be used with any SmartContractAccount
AlchemyWebSigner } from "@account-kit/signer";

        const 
const signer: AlchemyWebSigner
signer = new 
new AlchemyWebSigner(params: AlchemySignerParams): AlchemyWebSigner
Initializes an instance with the provided Alchemy signer parameters after parsing them with a schema.
AlchemyWebSigner({
         
client: {
    connection: ({
        apiKey: string;
        rpcUrl?: undefined;
        jwt?: undefined;
    } | {
        jwt: string;
        rpcUrl?: undefined;
        apiKey?: undefined;
    } | {
        rpcUrl: string;
        apiKey?: undefined;
        jwt?: undefined;
    } | {
        rpcUrl: string;
        jwt: string;
        apiKey?: undefined;
    }) & {
        chainAgnosticUrl?: string | undefined;
    };
    iframeConfig: {
        iframeContainerId: string;
        iframeElementId?: string | undefined;
    };
    rpId?: string | undefined;
    rootOrgId?: string | undefined;
    oauthCallbackUrl?: string | undefined;
    enablePopupOauth?: boolean | undefined;
} | AlchemySignerWebClient
client: {
           
connection: ({
    apiKey: string;
    rpcUrl?: undefined;
    jwt?: undefined;
} | {
    jwt: string;
    rpcUrl?: undefined;
    apiKey?: undefined;
} | {
    rpcUrl: string;
    apiKey?: undefined;
    jwt?: undefined;
} | {
    rpcUrl: string;
    jwt: string;
    apiKey?: undefined;
}) & {
    chainAgnosticUrl?: string | undefined;
}
connection: {
             
rpcUrl: string
rpcUrl: "/api/rpc",
           },
           
iframeConfig: {
    iframeContainerId: string;
}
iframeConfig: {
             
iframeContainerId: string
iframeContainerId: "alchemy-signer-iframe-container",
           },
         },
        });

        const 
const tx: SignedAuthorization<number>
tx = await 
const signer: AlchemyWebSigner
signer.
BaseAlchemySigner<AlchemySignerWebClient>.signAuthorization: (unsignedAuthorization: AuthorizationRequest<number>) => Promise<SignedAuthorization<number>>
Signs an EIP-7702 Authorization and then returns the authorization with the signature.
signAuthorization({
         
contractAddress: `0x${string}`
contractAddress: "0x1234123412341234123412341234123412341234",
         
chainId: number
Chain ID.
chainId: 1,
         
nonce: number
Nonce of the EOA to delegate to.
nonce: 0,
        });

signerType

"alchemy-signer" | "rn-alchemy-signer"

"alchemy-signer"

‐

signMessage

(msg) => Promise<`0x${string}`>

undefined

Signs a raw message after hashing it.

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const signature = await signer.signMessage("Hello, world!");

signTransaction

<serializer, transaction>(transaction, options?) => Promise<IsNarrowable<TransactionSerialized<GetTransactionType<transaction>>, `0x${string}`> extends true ? TransactionSerialized<GetTransactionType<transaction>> : `0x${string}`>

undefined

Serializes a transaction, signs it with a raw message, and then returns the serialized transaction with the signature.

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const tx = await signer.signTransaction({
15
 to: "0x1234",
16
 value: "0x1234",
17
 data: "0x1234",
18
});

signTypedData

<TTypedData, TPrimaryType>(params) => Promise<`0x${string}`>

undefined

Signs a typed message by first hashing it and then signing the hashed message using the signRawMessage method.

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const signature = await signer.signTypedData({
15
 domain: {},
16
 types: {},
17
 primaryType: "",
18
 message: {},
19
});

verifyMfa

(params) => Promise<{ multiFactors: MfaFactor[]; }>

undefined

Verifies a newly created MFA factor to complete the setup process.

Example

1
import { AlchemyWebSigner } from "@account-kit/signer";
2
3
const signer = new AlchemyWebSigner({
4
 client: {
5
   connection: {
6
     rpcUrl: "/api/rpc",
7
   },
8
   iframeConfig: {
9
     iframeContainerId: "alchemy-signer-iframe-container",
10
   },
11
 },
12
});
13
14
const result = await signer.verifyMfa({
15
  multiFactorId: "factor-id",
16
  multiFactorCode: "123456" // 6-digit code from authenticator app
17
});

Throws

If no user is authenticated

args

Omit<Extract<AuthParams, { type: "oauth"; }>, "type">

Authentication parameters omitting the type, which will be set to “oauth”

mfaFactorId?

string

mfaRequired

boolean

email

string

the email to lookup

params

GetUserParams

E extends keyof AlchemySignerEvents

event

E

the event to subscribe to

listener

AlchemySignerEvents[E]

the function to run when the event is emitted

providerId

string

The ID of the OAuth provider to be removed, as obtained from listOauthProviders

email

string

The email to set for the user

params

VerificationParams

An object containing the verification code

address

`0x${string}`

nonceManager?

NonceManager

publicKey

`0x${string}`

sign()?

(parameters) => Promise<`0x${string}`>

signAuthorization()?

(parameters) => Promise<SignAuthorizationReturnType>

signMessage()

(__namedParameters) => Promise<`0x${string}`>

signTransaction()

<serializer, transaction>(transaction, options?) => Promise<IsNarrowable<TransactionSerialized<GetTransactionType<transaction>>, `0x${string}`> extends true ? TransactionSerialized<GetTransactionType<transaction>> : `0x${string}`>

signTypedData()

<typedData, primaryType>(parameters) => Promise<`0x${string}`>

source

string

type

"local"

params

ValidateMultiFactorsArgs

Parameters for validating MFA factors