# Methods

These are the methods provided by the Wepin Android Login Library.

Methods can be used after initialization of Wepin Login Library.

## loginWithOauthProvider

```java
wepinLogin.loginWithOauthProvider(params)
```

An in-app browser will open and proceed to log in to the OAuth provider. To retrieve Firebase login information, you need to execute either the loginWithIdToken() or loginWithAccessToken() method.

**Parameters**

* `params` \<LoginOauth2Params>
  * `provider` <'google'|'naver'|'discord'|'apple'> - Provider for login
  * `clientId` \<String>

**Returns**

* CompletableFuture\<LoginOauthResult>
  * `provider` \<String> - login provider
  * `token` \<String> - accessToken (if provider is "naver" or "discord") or idToken (if provider is "google" or "apple")
  * `type` \<OauthTokenType> - type of token

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

```java
LoginOauth2Params loginOption = new LoginOauth2Params(
                    provider = "discord",
                    clientId = getString(R.string.default_discord_client_id),
                  )
CompletableFuture<LoginOauthResult> res = wepinLogin.loginWithOauthProvider(loginOption);
res.whenComplete((loginResponse, error) -> {
    if (error == null) {
        System.out.println("loginResponse: " + loginResponse);
        String privateKey = "private key for wepin id/access Token"
        // token sign 
        String sign = wepinLogin.getSignForLogin(loginResponse.token, privateKey)
        //call loginWithIdToken() or loginWithAccessToken()
    } else {
        // render error UI
        System.out.println("login error" + error.getMessage())
    }
});
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val loginOption = LoginOauth2Params(
                  provider = "discord",
                  clientId = getString(R.string.default_discord_client_id),
                )
wepinLogin.loginWithOauthProvider(loginOption).whenComplete { loginResponse, error ->
  if (error == null) {
      // render logged in UI
      println(loginResponse)
      val privateKey = "private key for wepin id/access Token"
      // token sign 
      wepinLogin.getSignForLogin(loginResponse.token, privateKey)
      //call loginWithIdToken() or loginWithAccessToken()
  } else {
      println("login error - ${error.message}")
      // render error UI
  }
}
```

{% endtab %}
{% endtabs %}

## signUpWithEmailAndPassword

```java
wepinLogin.signUpWithEmailAndPassword(params)
```

Sign up for Wepin Firebase with an email and password. For users who have not yet registered, a verification email will be sent, and a `REQUIRED_EMAIL_VERIFIED` error will occur if verification is required. If the user is already registered, an `EXISTED_EMAIL` error will occur, and you should proceed with the login process by calling [loginWithEmailAndPassword](#loginwithemailandpassword). Upon successful login, Firebase login information is returned.

**Parameters**

* `params` \<LoginWithEmailParams>
  * `email` \<String> - User email
  * `password` \<String> - User password
  * `locale` \<String> - **optional** Language for the verification email (default value: "en")

**Returns**

* CompletableFuture\<LoginResult>
  * `provider` \<Providers.EMAIL>
  * `token` \<FBToken>
    * `idToken` \<String> - wepin firebase idToken
    * `refreshToken` \` - wepin firebase refreshToken

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

```java
LoginWithEmailParams loginOption = new LoginWithEmailParams(
                    "abc@defg.com",
                    "abcdef123&",
                    "ko"
                  )
CompletableFuture<LoginResult> res = wepinLogin.signUpWithEmailAndPassword(loginOption);
res.whenComplete((loginResponse, error) -> {
    if (error == null) {
        System.out.println("loginResponse: " + infResponse);
    } else {
        // render error UI
        System.out.println("login error" + error.getMessage())
    }
});
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val loginOption = LoginWithEmailParams(
                  email = "abc@defg.com",
                  password = "abcdef123&",
                  language = "ko"
                )
wepinLogin.signUpWithEmailAndPassword(loginOption).whenComplete { loginResponse, error ->
  if (error == null) {
      // render logged in UI
      println(loginResponse)
      
  } else {
      println("login error - ${error.message}")
      // render error UI
  }
}
```

{% endtab %}
{% endtabs %}

## loginWithEmailAndPassword

```java
wepinLogin.loginWithEmailAndPassword(params)
```

This method logs in to the Wepin Firebase using your email and password. It returns Firebase login information upon successful login.

**Parameters**

* `params` \<LoginWithEmailParams>
  * `email` \<String> - User email
  * `password` \<String> - User password

**Returns**

* CompletableFuture\<LoginResult>
  * `provider` \<Providers.EMAIL>
  * `token` \<FBToken>
    * `idToken` \<String> - wepin firebase idToken
    * `refreshToken` \` - wepin firebase refreshToken

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

<pre class="language-java"><code class="lang-java"><strong>LoginWithEmailParams loginOption = new LoginWithEmailParams(
</strong>                    "abc@defg.com",
                    "abcdef123&#x26;",
                  )
CompletableFuture&#x3C;LoginResult> res = wepinLogin.loginWithEmailAndPassword(loginOption);
res.whenComplete((loginResponse, error) -> {
    if (error == null) {
        System.out.println("loginResponse: " + infResponse);
    } else {
        // render error UI
        System.out.println("login error" + error.getMessage())
    }
});
</code></pre>

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val loginOption = LoginWithEmailParams(
                  email = "abc@defg.com",
                  password = "abcdef123&",
                  language = "ko"
                )
wepinLogin.loginWithEmailAndPassword(loginOption).whenComplete { loginResponse, error ->
  if (error == null) {
      // render logged in UI
      println(loginResponse)
      
  } else {
      println("login error - ${error.message}")
      // render error UI
  }
}
```

{% endtab %}
{% endtabs %}

## loginWithIdToken

```java
wepinLogin.loginWithIdToken(params)
```

This method logs in to the Wepin Firebase using an external ID token. It returns Firebase login information upon successful login.

**Parameters**

* `params` \<LoginOauthIdTokenRequest>
  * `token` \<String> - ID token value to be used for login
  * `sign` \<String> - Signature value for the token provided as the first parameter.(Returned value of [getSignForLogin()](#getsignforlogin))

{% hint style="warning" %}
Note

If you choose to remove the authentication key issued from the [Wepin Workspace](https://workspace.wepin.io/), you may opt not to use the `sign`value. (Wepin Workspace > Development Tools menu > Login tab > Auth Key > Delete)

> The Auth Key menu is visible only if an authentication key was previously generated.

Starting from `WepinLogin` **version 1.1.0**, the `sign` value has been removed.\
If you are using version 1.1.0 or later, you **must delete the previously issued authentication key** from Wepin Workspace.
{% endhint %}

**Returns**

* CompletableFuture\<LoginResult>
  * `provider` \<Providers.EXTERNAL\_TOKEN>
  * `token` \<FBToken>
    * `idToken` \<String> - wepin firebase idToken
    * `refreshToken` \` - wepin firebase refreshToken

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

<pre class="language-java"><code class="lang-java"><strong>String token = "eyJHGciO....adQssw5c"
</strong>String sign = "9753d4dc...c63466b9"
LoginWithEmailParams loginOption = new LoginOauthIdTokenRequest(token, sign)
CompletableFuture&#x3C;LoginResult> res = wepinLogin.loginWithIdToken(loginOption);
res.whenComplete((loginResponse, error) -> {
    if (error == null) {
        System.out.println("loginResponse: " + infResponse);
    } else {
        // render error UI
        System.out.println("login error" + error.getMessage())
    }
});

</code></pre>

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val token = "eyJHGciO....adQssw5c"
val sign = "9753d4dc...c63466b9"
val loginOption = new LoginOauthIdTokenRequest(token, sign)
wepinLogin.loginWithIdToken(loginOption).whenComplete { loginResponse, error ->
  if (error == null) {
      // render logged in UI
      println(loginResponse)
      
  } else {
      println("login error - ${error.message}")
      // render error UI
  }
}
```

{% endtab %}
{% endtabs %}

## loginWithAccessToken

```java
wepinLogin.loginWithAccessToken(params)
```

This method logs in to the Wepin Firebase using an external access token. It returns Firebase login information upon successful login.

**Parameters**

* `params` \<LoginOauthAccessTokenRequest>
  * `provider` <"naver"|"discord"> - Provider that issued the access token
  * `accessToken` \<String> - Access token value to be used for login
  * `sign` \<String> - Signature value for the token provided as the first parameter. (Returned value of [getSignForLogin()](#getsignforlogin))

{% hint style="warning" %}
If you choose to remove the authentication key issued from the [Wepin Workspace](https://workspace.wepin.io/), you may opt not to use the `sign`value. (Wepin Workspace > Development Tools menu > Login tab > Auth Key > Delete)

> The Auth Key menu is visible only if an authentication key was previously generated.

Starting from `WepinLogin` **version 1.1.0**, the `sign` value has been removed.\
If you are using version 1.1.0 or later, you **must delete the previously issued authentication key** from Wepin Workspace.
{% endhint %}

**Returns**

* CompletableFuture\<LoginResult>
  * `provider` \<Providers.EXTERNAL\_TOKEN>
  * `token` \<FBToken>
    * `idToken` \<String> - wepin firebase idToken
    * `refreshToken` \` - wepin firebase refreshToken

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

```java
String accessToken = "eyJHGciO....adQssw5c"
String sign = "9753d4dc...c63466b9"
LoginOauthAccessTokenRequest loginOption = new LoginOauthAccessTokenRequest("discord", accessToken, sign)
CompletableFuture<LoginResult> res = wepinLogin.loginWithAccessToken(loginOption);
res.whenComplete((loginResponse, error) -> {
    if (error == null) {
        System.out.println("loginResponse: " + infResponse);
    } else {
        // render error UI
        System.out.println("login error" + error.getMessage())
    }
});
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val accessToken = "eyJHGciO....adQssw5c"
val sign = "9753d4dc...c63466b9"
val loginOption = LoginOauthAccessTokenRequest(
  provider = "discord",
  accessToken = accessToken, sign = sign
)
wepinLogin.loginWithAccessToken(loginOption).whenComplete { loginResponse, error ->
  if (error == null) {
    // render logged in UI
    println(loginResponse) 
  } else {
      println("login error - ${error.message}")
      // render error UI
  }
}
```

{% endtab %}
{% endtabs %}

## getRefreshFirebaseToken

```java
wepinLogin.getRefreshFirebaseToken()
```

This method retrieves the current firebase token's information from the Wepin.

**Parameters**

* void

**Returns**

* CompletableFuture\<LoginResult>
  * `provider` \<Providers>
  * `token` \<FBToken>
    * `idToken` \<String> - wepin firebase idToken
    * `refreshToken` \` - wepin firebase refreshToken

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

```java
CompletableFuture<WepinUser> res = wepinLogin.getRefreshFirebaseToken();
res.whenComplete((firebaseResponse, error) -> {
  if (error == null) {
      System.out.println("firebaseResponse: " + firebaseResponse);
      // render logged in UI
        println(firebaseResponse)
  } else {
      // render error UI
      System.out.println("login error: " + error.getMessage());
  }
});
```

{% endtab %}

{% tab title="Kotlin" %}

<pre class="language-kotlin"><code class="lang-kotlin">wepinLogin.getRefreshFirebaseToken().whenComplete { firebaseResponse, error ->
<strong>  if (error == null) {
</strong>    println(firebaseResponse)
    // render logged in UI
  } else {
    println("login error - ${error.message}")
    // render error UI
  }
}
</code></pre>

{% endtab %}
{% endtabs %}

## loginWepin

```java
wepinLogin.loginWepin(param)
```

This method logs the user into the Wepin application using the specified provider and token.

**Parameters**

The parameters should utilize the return values from the `loginWithEmailAndPassword()`, `loginWithIdToken()`, and `loginWithAccessToken()` methods within this module.

* \<LoginResult>
  * provider \<Providers>
  * token \<FBToken>
    * idToken \<String> - Wepin Firebase idToken
    * refreshToken\<String> - Wepin Firebase refreshToken

**Returns**

* CompletableFuture\<WepinUser> - A promise that resolves to an object containing the user's login status and information. The object includes:
  * status <'success'|'fail'> - The login status.
  * userInfo \<UserInfo> **optional** - The user's information, including:
    * userId \<String> - The user's ID.
    * email \<String> - The user's email.
    * provider <'google'|'apple'|'naver'|'discord'|'email'|'external\_token'> - The login provider.
    * use2FA \<Boolean> - Whether the user uses two-factor authentication.
  * walletId \<String> = The user's wallet ID.
  * userStatus: \<UserStatus> - The user's status of wepin login. including:
    * loginStats: <'complete' | 'pinRequired' | 'registerRequired'> - If the user's loginStatus value is not complete, it must be registered in the wepin.
    * pinRequired?:
  * token: \<Token> - The user's token of wepin.
    * accessToken: \<String>
    * refreshToken \<String>

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

```java
String accessToken = "eyJHGciO....adQssw5c"
String sign = "9753d4dc...c63466b9"
LoginOauthAccessTokenRequest loginOption = new LoginOauthAccessTokenRequest("discord", accessToken, sign)
CompletableFuture<LoginResult> res = wepinLogin.loginWithAccessToken(loginOption);
res.whenComplete((loginResponse, error) -> {
  if (error == null) {
      System.out.println("loginResponse: " + loginResponse);
      CompletableFuture<LoginResult> resWepin = wepinLogin.loginWepin(loginResponse);
      resWepin.whenComplete((loginWepinResponse, error) -> {
        if (error == null) {
            System.out.println("loginWepinResponse: " + loginWepinResponse);
            if(loginWepinResponse.loginStatus === WepinLoginStatus.PIN_REQUIRED||loginWepinResponse.loginStatus === WepinLoginStatus.REGISTER_REQUIRED) {
                // wepin registration
            }else {
              // render logged in UI
            }                
        } else {
            // render error UI
            System.out.println("login error" + error.getMessage())
        }
      })
  } else {
      // render error UI
      System.out.println("login error" + error.getMessage())
}
});
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val accessToken = "eyJHGciO....adQssw5c"
val sign = "9753d4dc...c63466b9"
val loginOption = LoginOauthAccessTokenRequest(
  provider = "discord",
  accessToken = accessToken, sign = sign
)
wepinLogin.loginWithAccessToken(loginOption).whenComplete { loginResponse, error ->
  if (error == null) {
      println(loginResponse)
      wepinLogin.loginWepin(loginResponse).whenComplete { loginWepinResponse, err ->
        if (err == null) {
            println(loginWepinResponse)
            if(loginWepinResponse.loginStatus === WepinLoginStatus.PIN_REQUIRED||loginWepinResponse.loginStatus === WepinLoginStatus.REGISTER_REQUIRED) {
              // wepin registration
          }else {
            // render logged in UI
          }                 
        } else {
            println("login err - ${err.message}")
            // render error UI
        }
    }   
  } else {
      println("login error - ${error.message}")
      // render error UI
  }
}
```

{% endtab %}
{% endtabs %}

## getCurrentWepinUser

```java
wepinLogin.getCurrentWepinUser()
```

This method retrieves the current logged-in user's information from the Wepin.

**Parameters**

* void

**Returns**

* CompletableFuture\<WepinUser> - A promise that resolves to an object containing the user's login status and information. The object includes:
  * status <'success'|'fail'> - The login status.
  * userInfo \<UserInfo> **optional** - The user's information, including:
    * userId \<String> - The user's ID.
    * email \<String> - The user's email.
    * provider <'google'|'apple'|'naver'|'discord'|'email'|'external\_token'> - The login provider.
    * use2FA \<Boolean> - Whether the user uses two-factor authentication.
  * walletId \<String> = The user's wallet ID.
  * userStatus: \<UserStatus> - The user's status of wepin login. including:
    * loginStats: <'complete' | 'pinRequired' | 'registerRequired'> - If the user's loginStatus value is not complete, it must be registered in the wepin.
    * pinRequired?:
  * token: \<Token> - The user's token of wepin.
    * accessToken: \<String>
    * refreshToken \<String>

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

<pre class="language-java"><code class="lang-java"><strong>CompletableFuture&#x3C;WepinUser> res = wepinLogin.getCurrentWepinUser();
</strong>res.whenComplete((wepinUserResponse, error) -> {
  if (error == null) {
      System.out.println("wepinUserResponse: " + wepinUserResponse);
      if (wepinUserResponse.loginStatus == WepinLoginStatus.PIN_REQUIRED || wepinUserResponse.loginStatus == WepinLoginStatus.REGISTER_REQUIRED) {
          // wepin registration
      } else {
          // render logged in UI
      }
  } else {
      // render error UI
      System.out.println("login error: " + error.getMessage());
  }
});
</code></pre>

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
wepinLogin.getCurrentWepinUser().whenComplete { wepinUserResponse, error ->
  if (error == null) {
      println(wepinUserResponse)
      if (wepinUserResponse.loginStatus == WepinLoginStatus.PIN_REQUIRED || wepinUserResponse.loginStatus == WepinLoginStatus.REGISTER_REQUIRED) {
          // wepin registration
      } else {
          // render logged in UI
      }
  } else {
      println("login error - ${error.message}")
      // render error UI
  }
}
```

{% endtab %}
{% endtabs %}

## logoutWepin

```java
wepinLogin.logoutWepin()
```

This method logs out the user logged into Wepin.

**Parameters**

* void

**Returns**

* CompletableFuture\<Boolean>

**Exception**

* [Wepin Error](#wepin-error)

**Example**

{% tabs %}
{% tab title="Java" %}

```java
CompletableFuture<Boolean> res = wepinLogin.logoutWepin();
res.whenComplete((logoutResponse, error) -> {
  if (error == null) {
      System.out.println("logoutResponse: " + logoutResponse);
  } else {
      // render error UI
      System.out.println("logout error" + error.getMessage())
  }
});
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
wepinLogin.logoutWepin().whenComplete { logoutResponse, error ->
  if (error == null) {
      println(logoutResponse)
  } else {
      println("logout error - ${error.message}")
      // render error UI
  }
}
```

{% endtab %}
{% endtabs %}

## getSignForLogin(Deprecated)

{% hint style="danger" %}
🔄 `getSignForLogin` is no longer supported\
• Starting from **v1.1.0**, the `getSignForLogin()` function is no longer supported because the `sign` parameter has been removed from the login process.\
• To log in without a signature, please delete the authentication key from **Wepin Workspace > Development Tools menu > Login tab > Auth Key > Delete**\
• The "Auth Key" menu is only visible if a key has been previously generated.
{% endhint %}

Generates signatures to verify the issuer. It is mainly used to generate signatures for login-related information such as ID tokens and access tokens.

```kotlin
wepinLogin.getSignForLogin(privKey, message);
```

**Parameters**

* `privKey` \<String> - The authentication key used for signature generation.
* `message` \<String> - The message or payload to be signed.

{% hint style="info" %}
The key for signing can be obtained from [Wepin Workspace](https://workspace.wepin.io/). In the Development Tools menu, click **Get your authentication key** on the Login tab to retrieve the authentication key.
{% endhint %}

**Returns**

* String - The generated signature.

{% hint style="warning" %}
The authentication key (`privKey`) must be stored securely and must not be exposed to the outside. It is recommended to execute the `getSignForLogin()` method on the backend rather than the frontend for enhanced security and protection of sensitive information.
{% endhint %}

**Example**

{% tabs %}
{% tab title="Java" %}

```java
String privKey = '0400112233445566778899001122334455667788990011223344556677889900'
String idToken = 'idtokenabcdef'
String sign = wepinLogin.getSignForLogin(privKey, idToken)
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val privKey = '0400112233445566778899001122334455667788990011223344556677889900'
val idToken = 'idtokenabcdef'
val sign = wepinLogin.getSignForLogin(privKey, idToken)
```

{% endtab %}
{% endtabs %}

## finalize

```java
wepinLogin.finalize()
```

This method finalizes the Wepin Login Library.

**Parameters**

* void

**Returns**

* void

**Example**

{% tabs %}
{% tab title="Java" %}

```java
wepinLogin.finalize()
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
wepinLogin.finalize()
```

{% endtab %}
{% endtabs %}

## Wepin Error

| Error Code                  | Error Message                     | Error Description                                                                                                                                                                                    |
| --------------------------- | --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `INVALID_APP_KEY`           | "Invalid app key"                 | The Wepin app key is invalid.                                                                                                                                                                        |
| `INVALID_PARAMETER` \`      | "Invalid parameter"               | One or more parameters provided are invalid or missing.                                                                                                                                              |
| `INVALID_LOGIN_PROVIDER`    | "Invalid login provider"          | The login provider specified is not supported or is invalid.                                                                                                                                         |
| `INVALID_TOKEN`             | "Token does not exist"            | The token does not exist.                                                                                                                                                                            |
| `INVALID_LOGIN_SESSION`     | "Invalid Login Session"           | The login session information does not exist.                                                                                                                                                        |
| `NOT_INITIALIZED_ERROR`     | "Not initialized error"           | The WepinLoginLibrary has not been properly initialized.                                                                                                                                             |
| `ALREADY_INITIALIZED_ERROR` | "Already initialized"             | The WepinLoginLibrary is already initialized, so the logout operation cannot be performed again.                                                                                                     |
| `NOT_ACTIVITY`              | "Context is not activity"         | The Context is not an activity                                                                                                                                                                       |
| `USER_CANCELLED`            | "User cancelled"                  | The user has cancelled the operation.                                                                                                                                                                |
| `UNKNOWN_ERROR`             | "An unknown error occurred"       | An unknown error has occurred, and the cause is not identified.                                                                                                                                      |
| `NOT_CONNECTED_INTERNET`    | "No internet connection"          | The system is unable to detect an active internet connection.                                                                                                                                        |
| `FAILED_LOGIN`              | "Failed to Oauth log in"          | The login attempt has failed due to incorrect credentials or other issues.                                                                                                                           |
| `ALREADY_LOGOUT`            | "Already Logout"                  | The user is already logged out, so the logout operation cannot be performed again.                                                                                                                   |
| `INVALID_EMAIL_DOMAIN`      | "Invalid email domain"            | The provided email address's domain is not allowed or recognized by the system.                                                                                                                      |
| `FAILED_SEND_EMAIL`         | "Failed to send email"            | The system encountered an error while sending an email. This is because the email address is invalid or we sent verification emails too often. Please change your email or try again after 1 minute. |
| `REQUIRED_EMAIL_VERIFIED`   | "Email verification required"     | Email verification is required to proceed with the requested operation.                                                                                                                              |
| `INCORRECT_EMAIL_FORM`      | "Incorrect email format"          | The provided email address does not match the expected format.                                                                                                                                       |
| `INCORRECT_PASSWORD_FORM`   | "Incorrect password format"       | The provided password does not meet the required format or criteria.                                                                                                                                 |
| `NOT_INITIALIZED_NETWORK`   | "Network Manager not initialized" | The network or connection required for the operation has not been properly initialized.                                                                                                              |
| `REQUIRED_SIGNUP_EMAIL`     | "Email sign-up required."         | The user needs to sign up with an email address to proceed.                                                                                                                                          |
| `FAILED_EMAIL_VERIFIED`     | "Failed to verify email."         | The WepinLoginLibrary encountered an issue while attempting to verify the provided email address.                                                                                                    |
| `FAILED_PASSWORD_SETTING`   | "Failed to set password."         | The WepinLoginLibrary failed to set the password.                                                                                                                                                    |
| `EXISTED_EMAIL`             | "Email already exists."           | The provided email address is already registered in Wepin.                                                                                                                                           |