​
Prerequisites

This guide assumes that you have completed the setup guide.

​
Check user’s authentication state

coroutineScope.launch {
  val authState = privy.getAuthState()

  when(authState) {
      is AuthState.Authenticated -> {
          // User is authenticated. Grab the user's linked accounts
          val privyUser = authState.user
      }
      AuthState.NotReady -> {
          // Privy was just initialized and has not determined auth state yet
          // authState will never be this case after calling getAuthState()
      }
      is AuthState.AuthenticatedUnverified -> {
          // Prior user session exists, but can't be verified due to no network connectivity.
          // Privy will automatically attempt to verify authenticated state when network is restored.
      }
      AuthState.Unauthenticated -> {
          // User in not authenticated.
      }
  }
}

​
Authenticate your user

This quickstart guide will demonstrate how to authenticate a user with a one time password as an example, but Privy supports many authentication methods. Explore our Authentication docs to learn about other methods such as socials, passkeys, and external wallets to authenticate users in your app.
Privy offers a variety of authentication mechanisms. The example below showcases authenticating a user via SMS. This is a two step process:
  1. Send an OTP to the user provided phone number.
  2. Verify the OTP sent to the user.
Please be sure to configure SMS as a login method on the Privy Developer Dashboard under User Management > Authentication.

​
1. Send an OTP to the user’s phone number via SMS

After collecting and validating your users phone number, send an OTP by calling the sendCode method. Note: you must provide the phone number in E.164 format. 
val result: Result<Unit> = privy.sms.sendCode(phoneNumber = "+14155552671")

result.fold(
  onSuccess = {
    // OTP was successfully sent
  },
  onFailure = {
    println("Error sending OTP: ${it.message}")
  }
)
If the OTP is sent successfully, sendCode will return Result.success with no associated type. If the provided phone number is invalid, or sending the OTP fails, sendCode will return Result.failure.

​
2. Authenticate with OTP

The user will then receive an SMS with a 6-digit OTP. Prompt for this OTP within your application, then authenticate the user with the loginWithCode method. Pass the following parameters to this method: 
val result: Result<PrivyUser> = privy.sms.loginWithCode(code = "123456", phoneNumber = "+14155552671")

result.fold(
  onSuccess = { user ->
    // User logged in
  },
  onFailure = {
    println("Error logging in user: ${it.message}")
  }
)
If the OTP/phone number combination is valid, Privy will successfully authenticate your user and loginWithCode will return Result.success with an encapsulated PrivyUser. If the provided OTP/phone number combination is invalid, loginWithCode will return Result.failure.

​
The Embedded wallet

​
Create an embedded wallet

To create an EVM embedded wallet for your user, call the createEthereumWallet method on your PrivyUser instance.
public interface PrivyUser {
  // Other privy user methods

  public suspend fun createEthereumWallet(allowAdditional: Boolean = false):  Result<EmbeddedEthereumWallet>

  // ...
}
If a wallet is successfully created for the user, an EmbeddedEthereumWallet object is returned as an encapsulated value of Result.success.This method will Result.failure if:
  • The user is not authenticated
  • If a user already has 9 or more wallets
  • If the network call to create the wallet fails
  • If a user already has an embedded wallet and allowAdditional is not set to true.

​
Example

privy.user?.let { privyUser ->
  // non null user means user is authenticated
  val result = privyUser.createEthereumWallet(allowAdditional = false)

  result.fold(
    onSuccess = { ethereumWallet ->
      println("Created wallet with address: ${ethereumWallet.address}")
    },
    onFailure = {
      println("Error creating Ethereum wallet: ${it.message}")
    }
  )
}

​
Using the embedded wallet

To enable your app to request signatures and transactions from the embedded wallet, Privy Ethereum embedded wallets expose a provider inspired by the EIP-1193 provider standard. This allows you request signatures and transactions from the wallet via a familiar JSON-RPC API (e.g. personal_sign).Once you have an instance of an EmbeddedEthereumWallet, you can make RPC requests by using the provider: EmbeddedEthereumWalletProvider hook and using its request method. For example, wallet.provider.request(request: rpcRequest). This request method will suspend and await if the embedded wallet needs to wait for any internal ready state.
public interface EmbeddedEthereumWalletProvider {
 /**
  * Sends a request to the Ethereum provider
  *
  * @param The RPC request
  * @return The response received
  */
 public suspend fun request(request: EthereumRpcRequest): Result<EthereumRpcResponse>
}
As a parameter to this method, to this method, pass an EthereumRpcRequest object that contains:
  • method: the name of the JSON-RPC method for the wallet to execute (e.g. 'personal_sign')
  • params: an array of parameters required by your specified method
By default, embedded wallets are connected to the Ethereum mainnet. To send a transaction on a different network, simply set the wallet’s chainId in the transaction request.Example usage:
// Get Privy user
val user = privy.user

// check if user is authenticated
if (user != null) {
  // Retrieve list of user's embedded Ethereum wallets
  val ethereumWallets = user.embeddedEthereumWallets

  if (ethereumWallets.isNotEmpty()) {
    // Grab the desired wallet. Here, we retrieve the first wallet
    val ethereumWallet = ethereumWallets.first()

    // Make an rpc request
    ethereumWallet.provider.request(
      request = EthereumRpcRequest(
        method = "personal_sign",
        params = listOf("A message to sign", ethereumWallet.address),
      ),
    )
  }
}