# 메서드

## loginWithOauthProvider

```kotlin
suspend fun loginWithOauthProvider(params: LoginOauth2Params): LoginOauthResult
```

인앱 브라우저가 열리고 OAuth 프로바이더에 로그인합니다. Firebase 로그인 정보를 가져오려면 `loginWithIdToken()` 또는 `loginWithAccessToken()` 메서드를 호출해야 합니다.

#### **Parameters**

* **params** `<LoginOauth2Params>`
  * **provider** `<'google'|'naver'|'discord'|'apple'>`\
    로그인 프로바이더
  * **clientId**  `<String>`\
    OAuth 로그인 프로바이더의 클라이언트 ID

**Returns**

* **\<LoginOauthResult>**
  * **provider** `<String>`\
    사용된 OAuth Provider 의 이름
  * **token** `<String>`\
    accessToken(provider 가  'naver' 또는 'discord') 또는 idToken(provider 가 'google' 또는 'apple')
  * **type** `<OauthTokenType>`\
    OAuth 토큰의 유형 (id\_token , accessToken)

**Exception**

* [WepinError](#wepinerror)

**Example**

<pre class="language-kotlin"><code class="lang-kotlin"><strong>coroutineScope.launch { 
</strong>    wepinLogin.loginWithOauthProvider(LoginOauth2Params(
        provider = "google",
        clientId = "your-google-client-id",
    ))
}
</code></pre>

## signUpWithEmailAndPassword

```kotlin
suspend fun signUpWithEmailAndPassword(params: LoginWithEmailParams): LoginResult
```

이메일과 비밀번호로 Wepin Firebase에 회원가입을 합니다. 가입되지 않은 사용자의 경우 검증 이메일이 전송되며, `REQUIRED_EMAIL_VERIFIED` 오류가 발생합니다. 이미 가입된 사용자의 경우, `EXISTED_EMAIL` 오류가 발생하며 [loginWithEmailAndPassword](#loginwithemailandpassword)를 호출하여 로그인 프로세스를 진행합니다. 로그인에 성공하면 Firebase 로그인 정보를 반환합니다.

**Parameters**

* **params** `<LoginWithEmailParams>`
  * **email** `<String>`\
    사용자 이메일
  * **password** `<String>`\
    사용자 비밀번호
  * **locale** `<String>`\
    인증 이메일의 언어 설정(기본 값: 'en')

**Returns**

* **\<LoginResult>**
  * **provider** `<Providers.EMAIL>`\
    로그인에 사용된 프로바이더
  * **token** `<FBToken>`
    * **idToken** `<String>`\
      Wepin Firebase ID Token
    * **refreshToken** `<String>`\
      Wepin Firebase refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
coroutineScope.launch { 
    wepinLogin.signUpWithEmailAndPassword(
        LoginWithEmailParams(
            email = "abc@defg.com", 
            password = "abcdef123$"
        )
    )
}
```

## loginWithEmailAndPassword

<pre class="language-kotlin"><code class="lang-kotlin"><strong>suspend fun loginWithEmailAndPassword(params: LoginWithEmailParams): LoginResult
</strong></code></pre>

이메일과 비밀번호를 사용하여 Wepin Firebase 에 로그인합니다. 로그인에 성공하면 Firebase 로그인 정보를 반환합니다.

**Parameters**

* **params** `<LoginWithEmailParams>`
  * **email** `<String>`\
    사용자 이메일
  * **password** `<String>`\
    사용자 비밀번호

**Returns**

* **\<LoginResult>**
  * **provider** `<Providers.EMAIL>`\
    로그인에 사용된 프로바이더
  * **token** `<FBToken>`
    * **idToken** `<String>`\
      Wepin Firebase ID Token
    * **refreshToken** `<String>`\
      Wepin Firebase refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
coroutineScope.launch { 
    wepinLogin.loginWithEmailAndPassword(
        LoginWithEmailParams(
            email = "abc@defg.com", 
            password = "abcdef123$"
        )
    )
}
```

## loginWithIdToken

<pre class="language-kotlin"><code class="lang-kotlin"><strong>suspend fun loginWithIdToken(params: LoginOauthIdTokenRequest): LoginResult
</strong></code></pre>

외부 ID Token을 사용하여 WepinFirebase에 로그인합니다. 로그인에 성공하면 Firebase 로그인 정보를 반환합니다.

**Parameters**

* **params** `<LoginOauthIdTokenRequest>`
  * **idToken** `<String>`\
    로그인에 사용될 ID 토큰 값
  * **sign** `<String>` (*optional*)\
    ID 토큰의 서명 값 ([`getSignForLogin()`](#getsignforlogin) 의 반환 값)

{% hint style="info" %}
wepin-compose-sdk-login-v1 버전 0.0.10부터 `sign` 값은 선택사항입니다. [Wepin Workspace](https://workspace.wepin.io/)에서 발급된 인증키를 삭제(Wepin Workspace > Development Tools 메뉴 > Login 탭 > Auth Key > Delete)한 경우, `sign` 값을 사용하지 않아도 됩니다. 인증키가 이미 생성된 경우에만 Auth Key 메뉴가 표시됩니다.
{% endhint %}

**Returns**

* **\<LoginResult>**
  * **provider** \<Providers.EXTERNAL\_TOKEN> - 로그인에 사용된 Provider
  * **token** `<FBToken>`
    * **idToken** `<String>`\
      Wepin Firebase ID 토큰&#x20;
    * **refreshToken** `<String>`\
      Wepin Firebase refresh 토큰

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
  coroutineScope.launch {
      try {
          val loginOption = LoginOauthIdTokenRequest(idToken = token)
          val loginResponse = wepinLogin.loginWithIdToken(loginOption)
          setResponse(loginResponse)
          setText("$loginResponse")
      } catch (e: Exception) {
          setResponse(null)
          setText("fail - ${e.message}")
      }
  }

```

## loginWithAccessToken

```kotlin
suspend fun loginWithAccessToken(params: LoginOauthAccessTokenRequest): LoginResult
```

외부 Access Token을 사용하여 Wepin Firebase에 로그인합니다. 로그인에 성공하면 Firebase 로그인 정보를 반환합니다.

**Parameters**

* **params** `<LoginOauthAccessTokenRequest>`
  * **provider** `<'naver'|'discord'|'facebook'>`\
    Access Token을 발급한 프로바이더
  * **accessToken** `<String>`\
    로그인에 사용될 Access Token 값
  * **sign** `<String>` (*optional*)
  * Access Token의 서명 값 ([`getSignForLogin()`](#getsignforlogin) 의 반환 값)

{% hint style="info" %}
wepin-compose-sdk-login-v1 버전 0.0.10부터 `sign` 값은 선택사항입니다. [Wepin Workspace](https://workspace.wepin.io/)에서 발급된 인증키를 삭제(Wepin Workspace > Development Tools 메뉴 > Login 탭 > Auth Key > Delete)한 경우, `sign` 값을 사용하지 않아도 됩니다. 인증키가 이미 생성된 경우에만 Auth Key 메뉴가 표시됩니다.
{% endhint %}

**Returns**

* **\<LoginResult>**
  * **provider** `<Provider.EXTERNAL_TOKEN>`\
    로그인에 사용된 프로바이더
  * **token** `<FBToken>`
    * **idToken** `<String>`\
      Wepin Firebase ID Token
    * **refreshToken** `<String>`\
      Wepin Firebase refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
  coroutineScope.launch {
      try {
          val loginOption = LoginOauthAccessTokenRequest(provider, token)
          val loginResponse = wepinLogin.loginWithAccessToken(loginOption)
          setResponse(loginResponse)
          setText("$loginResponse")
      } catch (e: Exception) {
          setResponse(null)
          setText("fail - ${e.message}")
      }
  }

```

## getRefreshFirebaseToken

```kotlin
suspend fun getRefreshFirebaseToken(): LoginResult
```

현재 Wepin Firebase 토큰의 정보를 가져옵니다.

**Parameters**

* None

**Returns**

* **\<LoginResult>**
  * **provider** `<Provider.EXTERNAL_TOKEN>`\
    로그인에 사용된 프로바이더
  * **token** `<FBToken>`
    * **idToken** `<String>`\
      Wepin Firebase ID Token
    * **refreshToken** `<String>`\
      Wepin Firebase refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
coroutineScope.launch { 
    wepinLogin.getRefreshFirebaseToken()
}
```

## loginFirebaseWithOauthProvider

버전 0.0.10 이상부터 지원됩니다.

```kotlin
suspend fun loginFirebaseWithOauthProvider(params: LoginOauth2Params): LoginResult?
```

이 메서드는 `loginWithOauthProvider`, `loginWithIdToken`, `loginWithAccessToken`의 기능을 결합한 것입니다. 지정된 OAuth 로그인 제공자를 통해 Wepin Firebase에 로그인하기 위해 인앱 브라우저를 엽니다. 로그인에 성공하면 Firebase 로그인 정보를 반환합니다. 이 메서드는 suspend 메서드이므로 다른 suspend 메서드 안에서 호출하거나 코루틴 내에서 호출할 수 있습니다.

**Parameters**

* **params** `<LoginOauth2Params>`
  * **provider**  `<'google'|'naver'|'discord'|'apple'>`\
    로그인 프로바이더
  * **clientId**  `<String>`\
    OAuth 로그인 프로바이더의 클라이언트 ID

**Returns**

* **\<LoginResult>**
  * **provider** `<Provider.EXTERNAL_TOKEN>`\
    로그인에 사용된 프로바이더
  * **token** `<FBToken>`
    * **idToken** `<String>`\
      Wepin Firebase ID Token
    * **refreshToken** `<String>`\
      Wepin Firebase refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
  val loginOption = LoginOauth2Params(
                      provider = "google",
                      clientId = "google-client-id",
                    )
  coroutineScope.launch { 
      try {
          val loginResponse = wepinLogin.loginFirebaseWithOauthProvider(loginOption)
      } catch (e: Exception) {
          setResponse(null)
          setText("fail - $e")
      }
  }

```

## loginWepinWithOauthProvider

버전 0.0.10 이상부터 지원됩니다.

```kotlin
suspend fun loginWepinWithOauthProvider(params: LoginOauth2Params): WepinUser?
```

이 메서드는 `loginFirebaseWithOauthProvider`와 `loginWepin`의 기능을 결합한 것입니다. 지정된 OAuth 로그인 제공자를 통해 Wepin에 로그인하기 위해 인앱 브라우저를 엽니다. 로그인에 성공하면 Wepin 사용자 정보를 반환합니다. 이 메서드는 suspend 메서드이므로 다른 suspend 메서드 안에서 호출하거나 코루틴 내에서 호출할 수 있습니다.

{% hint style="info" %}
이 메서드는 [Wepin Workspace](https://workspace.wepin.io/login)에서 인증키를 삭제(Wepin Workspace > Developer Tools 메뉴 > Login 탭 > Auth Key > Delete)한 후에만 사용할 수 있습니다. 인증키가 이미 생성된 경우에만 Auth Key 메뉴가 표시됩니다.
{% endhint %}

**Parameters**

* **params** `<LoginOauth2Params>`
  * **provider** `<'google'|'naver'|'discord'|'apple'>`\
    로그인 프로바이더
  * **clientId**  `<String>`\
    OAuth 로그인 프로바이더의 클라이언트 ID

**Returns**

* **\<WepinUser>** (*optional*)
  * **status** `<'success' | 'fail'>`\
    로그인 상태
  * **userInfo** `<UserInfo>`\
    사용자 정보 (*optional*)
    * **userId** `<String>`\
      사용자의 ID
    * **email** `<String>`\
      사용자의 이메일
    * **provider** `<'google'|'naver'|'discord'|'apple'|'email' | 'external_token'>`\
      로그인 Provider
    * **use2FA** `<Boolean>`\
      사용자가 이중 인증을 사용하는지 여부
  * **walletId** `<String>`\
    사용자의 지갑 ID
  * **userStatus** `<UserStatus>`\
    사용자의 Wepin 로그인 상태 (*optional*)
    * **loginStatus** `<WepinLoginStatus - 'complete' | 'pinRequired' | 'registerRequired'>`\
      사용자의 loginStatus 가 'complete' 상태가 아닌 경우, 사용자는 위핀에 register 해야 합니다.
    * **pinRequired** \<Boolean>\
      PIN 이 필요한지 여부
  * **token** `<Token>`\
    사용자의 Wepin Token
    * **accessToken** `<String>`\
      Access Token
    * **refreshToken** `<String>`\
      Refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
  val loginOption = LoginOauth2Params(
                      provider = "google",
                      clientId = "google-client-id",
                    )
  coroutineScope.launch { 
      try {
          val userInfo = wepinLogin.loginWepinWithOauthProvider(loginOption)
      } catch (e: Exception) {
          setResponse(null)
          setText("fail - $e")
      }
  }
```

## loginWepinWithEmailAndPassword

버전 0.0.10 이상부터 지원됩니다.

```kotlin
suspend fun loginWepinWithEmailAndPassword(params: LoginWithEmailParams): WepinUser?
```

이 메서드는 `loginWithEmailAndPassword`와 `loginWepin`의 기능을 통합한 것입니다. `loginWepinWithEmailAndPassword` 메서드는 제공된 이메일과 비밀번호를 사용하여 Wepin에 로그인합니다. 로그인에 성공하면 Wepin 사용자 정보를 반환합니다. 이 메서드는 suspend 메서드이므로 다른 suspend 메서드 안에서 호출하거나 코루틴 내에서 호출할 수 있습니다.

**Parameters**

* **params** `<LoginWithEmailParams>`
  * **email** `<String>`\
    사용자 이메일
  * **password** `<String>`\
    사용자 비밀번호

**Returns**

* **\<WepinUser>** (*optional*)
  * **status** `<'success' | 'fail'>`\
    로그인 상태
  * **userInfo** `<UserInfo>`\
    사용자 정보 (*optional*)
    * **userId** `<String>`\
      사용자의 ID
    * **email** `<String>`\
      사용자의 이메일
    * **provider** `<'google'|'naver'|'discord'|'apple'|'email' | 'external_token'>`\
      로그인 Provider
    * **use2FA** `<Boolean>`\
      사용자가 이중 인증을 사용하는지 여부
  * **walletId** `<String>`\
    사용자의 지갑 ID
  * **userStatus** `<UserStatus>`\
    사용자의 Wepin 로그인 상태 (*optional*)
    * **loginStatus** `<WepinLoginStatus - 'complete' | 'pinRequired' | 'registerRequired'>`\
      사용자의 loginStatus 가 'complete' 상태가 아닌 경우, 사용자는 위핀에 register 해야 합니다.
    * **pinRequired** \<Boolean>\
      PIN 이 필요한지 여부
  * **token** `<Token>`\
    사용자의 Wepin Token
    * **accessToken** `<String>`\
      Access Token
    * **refreshToken** `<String>`\
      Refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
  val loginOption = LoginWithEmailParams(email, password)
  coroutineScope.launch {
      try {
          val response = wepinLogin.loginWepinWithEmailAndPassword(loginOption)
          setResponse(response)
          setText("$response")
      } catch (e: Exception) {
          setText("fail - $e")
      }
  }
```

## loginWepinWithIdToken

버전 0.0.10 이상부터 지원됩니다.

```kotlin
suspend fun loginWepinWithIdToken(params: LoginOauthIdTokenRequest): WepinUser?
```

이 메서드는 `loginWithIdToken`과 `loginWepin`의 기능을 통합한 것입니다. `loginWepinWithIdToken` 메서드는 외부 ID 토큰을 사용하여 Wepin에 로그인합니다. 로그인에 성공하면 Wepin 사용자 정보를 반환합니다. 이 메서드는 suspend 메서드이므로 다른 suspend 메서드 안에서 호출하거나 코루틴 내에서 호출할 수 있습니다.

**Parameters**

* **params** `<LoginOauthIdTokenRequest>`
  * **idToken** `<String>`\
    로그인에 사용될 ID 토큰 값
  * **sign** `<String>` (*optional*)\
    ID 토큰의 서명 값 ([`getSignForLogin()`](#getsignforlogin) 의 반환 값)

{% hint style="info" %}
wepin-compose-sdk-login-v1 버전 0.0.10부터 `sign` 값은 선택 사항입니다. [Wepin Workspace](https://workspace.wepin.io/)에서 발급된 인증키를 삭제(Wepin Workspace > Developer Tools 메뉴 > Login 탭 > Auth Key > Delete)한 경우, `sign` 값을 사용하지 않아도 됩니다. 인증 키가 이미 생성된 경우에만 Auth Key 메뉴가 표시됩니다.
{% endhint %}

**Returns**

* **\<WepinUser>** (*optional*)
  * **status** `<'success' | 'fail'>`\
    로그인 상태
  * **userInfo** `<UserInfo>`\
    사용자 정보 (*optional*)
    * **userId** `<String>`\
      사용자의 ID
    * **email** `<String>`\
      사용자의 이메일
    * **provider** `<'google'|'naver'|'discord'|'apple'|'email' | 'external_token'>`\
      로그인 Provider
    * **use2FA** `<Boolean>`\
      사용자가 이중 인증을 사용하는지 여부
  * **walletId** `<String>`\
    사용자의 지갑 ID
  * **userStatus** `<UserStatus>`\
    사용자의 Wepin 로그인 상태 (*optional*)
    * **loginStatus** `<WepinLoginStatus - 'complete' | 'pinRequired' | 'registerRequired'>`\
      사용자의 loginStatus 가 'complete' 상태가 아닌 경우, 사용자는 위핀에 register 해야 합니다.
    * **pinRequired** \<Boolean>\
      PIN 이 필요한지 여부
  * **token** `<Token>`\
    사용자의 Wepin Token
    * **accessToken** `<String>`\
      Access Token
    * **refreshToken** `<String>`\
      Refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
  coroutineScope.launch {
      try {
          val loginOption = LoginOauthIdTokenRequest(idToken = token)
          val userInfo = wepinLogin.loginWepinWithIdToken(loginOption)
      } catch (e: Exception) {
          setResponse(null)
          setText("fail - ${e.message}")
      }
  }

```

## loginWepinWithAccessToken

버전 0.0.10 이상부터 지원됩니다.

```kotlin
suspend fun loginWepinWithAccessToken(params: LoginOauthAccessTokenRequest): WepinUser?
```

This method integrates the functions of `loginWithAccessToken` and `loginWepin`. The `loginWepinWithAccessToken` method logs the user into Wepin using an external access token. Upon successful login, it returns Wepin user information. This method is a suspend method, so you can call it within another suspend method or in a coroutine.

**Parameters**

* **params** `<LoginOauthAccessTokenRequest>`
  * **provider** `<'naver'|'discord'|'facebook'>`\
    Access Token을 발급한 프로바이더
  * **accessToken** `<String>`\
    로그인에 사용될 Access Token 값
  * **sign** `<String>` (*optional*)
  * Access Token의 서명 값 ([`getSignForLogin()`](#getsignforlogin) 의 반환 값)

{% hint style="info" %}
wepin-compose-sdk-login-v1 버전 0.0.10부터 `sign` 값은 선택 사항입니다. [Wepin Workspace](https://workspace.wepin.io/)에서 발급된 인증키를 삭제(Wepin Workspace > Developer Tools 메뉴 > Login 탭 > Auth Key > Delete)한 경우, `sign` 값을 사용하지 않아도 됩니다. 인증 키가 이미 생성된 경우에만 Auth Key 메뉴가 표시됩니다.
{% endhint %}

**Returns**

* **\<WepinUser>** (*optional*)
  * **status** `<'success' | 'fail'>`\
    로그인 상태
  * **userInfo** `<UserInfo>`\
    사용자 정보 (*optional*)
    * **userId** `<String>`\
      사용자의 ID
    * **email** `<String>`\
      사용자의 이메일
    * **provider** `<'google'|'naver'|'discord'|'apple'|'email' | 'external_token'>`\
      로그인 Provider
    * **use2FA** `<Boolean>`\
      사용자가 이중 인증을 사용하는지 여부
  * **walletId** `<String>`\
    사용자의 지갑 ID
  * **userStatus** `<UserStatus>`\
    사용자의 Wepin 로그인 상태 (*optional*)
    * **loginStatus** `<WepinLoginStatus - 'complete' | 'pinRequired' | 'registerRequired'>`\
      사용자의 loginStatus 가 'complete' 상태가 아닌 경우, 사용자는 위핀에 register 해야 합니다.
    * **pinRequired** \<Boolean>\
      PIN 이 필요한지 여부
  * **token** `<Token>`\
    사용자의 Wepin Token
    * **accessToken** `<String>`\
      Access Token
    * **refreshToken** `<String>`\
      Refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
  coroutineScope.launch {
      try {
          val loginOption = LoginOauthAccessTokenRequest(provider, token)
          val userInfo = wepinLogin.loginWepinWithAccessToken(loginOption)
          setResponse(userInfo)
          setText("$userInfo")
      } catch (e: Exception) {
          setResponse(null)
          setText("fail - ${e.message}")
      }
  }
```

## loginWepin

```kotlin
suspend fun loginWepin(params: LoginResult?): WepinUser
```

Wepin Firebase 토큰을 사용하여 위핀에 로그인 합니다.

**Parameters**

* **params** \<LoginResult> - [`loginWithEmailAndPassword()`](#loginwithemailandpassword), [`loginWithIdToken()`](#loginwithidtoken), [`loginWithAcccessToken()`](#loginwithaccesstoken) 의 반환 값

**Returns**

* **\<WepinUser>** (*optional*)
  * **status** `<'success' | 'fail'>`\
    로그인 상태
  * **userInfo** `<UserInfo>`\
    사용자 정보 (*optional*)
    * **userId** `<String>`\
      사용자의 ID
    * **email** `<String>`\
      사용자의 이메일
    * **provider** `<'google'|'naver'|'discord'|'apple'|'email' | 'external_token'>`\
      로그인 Provider
    * **use2FA** `<Boolean>`\
      사용자가 이중 인증을 사용하는지 여부
  * **walletId** `<String>`\
    사용자의 지갑 ID
  * **userStatus** `<UserStatus>`\
    사용자의 Wepin 로그인 상태 (*optional*)
    * **loginStatus** `<WepinLoginStatus - 'complete' | 'pinRequired' | 'registerRequired'>`\
      사용자의 loginStatus 가 'complete' 상태가 아닌 경우, 사용자는 위핀에 register 해야 합니다.
    * **pinRequired** \<Boolean>\
      PIN 이 필요한지 여부
  * **token** `<Token>`\
    사용자의 Wepin Token
    * **accessToken** `<String>`\
      Access Token
    * **refreshToken** `<String>`\
      Refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
coroutineScope.launch { 
    val wepinLogin: WepinLogin = WepinLogin(
        WepinLoginOptions(
            context = context,
            appId = appId,
            appKey = appKey
        )
    )
    wepinLogin.init()
    
    val response = wepinLogin.loginWithOauthProvider(
        LoginOauth2Params(
            provider = "google",
            clientId = "your-google-client-id"
        )
    )
    val sign = wepinLogin.getSignForLogin(
        privateKeyHex = "private key", 
        message = response.token
    )
    var loginResult: LoginResult? = null
    if (response.provider == "naver" || response.provider = "discord") {
        loginResult = wepinLogin.loginWithAccessToken(
            LoginOauthAccessTokenRequest(
                provider = response.provider,
                token = response.token,
                sign = sign
            )
        )
    } else {
        loginResult = wepinLogin.loginWithIdToken(
            LoginOauthIdTokenRequest(
                idToken = response.token,
                sign = sign
            )
        )
    }
    val userInfo = wepinLogin.loginWepin(loginResult)
    val userStatus = userInfo.userStatus
    if (userStatus.loginStatus != WepinLoginStatus.COMPLETE) {
        //Wepin Register 코드..
    }
}
```

## getCurrentWepinUser

```kotlin
suspend fun getCurrentWepinUser(): WepinUser
```

위핀에 현재 로그인한 사용자의 정보를 가져옵니다.

**Parameters**

* None

**Returns**

* **\<WepinUser>**&#x20;
  * **status** `<'success' | 'fail'>`\
    로그인 상태
  * **userInfo** `<UserInfo>`\
    사용자 정보 (*optional*)
    * **userId** `<String>`\
      사용자의 ID
    * **email** `<String>`\
      사용자의 이메일
    * **provider** `<'google'|'naver'|'discord'|'apple'|'email' | 'external_token'>`\
      로그인 Provider
    * **use2FA** `<Boolean>`\
      사용자가 이중 인증을 사용하는지 여부
  * **walletId** `<String>`\
    사용자의 지갑 ID
  * **userStatus** `<UserStatus>`\
    사용자의 Wepin 로그인 상태 (*optional*)
    * **loginStatus** `<WepinLoginStatus - 'complete' | 'pinRequired' | 'registerRequired'>`\
      사용자의 loginStatus 가 'complete' 상태가 아닌 경우, 사용자는 위핀에 register 해야 합니다.
    * **pinRequired** \<Boolean>\
      PIN 이 필요한지 여부
  * **token** `<Token>`\
    사용자의 Wepin 토큰
    * **accessToken** `<String>`\
      Access Token
    * **refreshToken** `<String>`\
      Refresh Token

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
coroutineScope.launch {
    val userInfo = wepinLogin.getCurrentWepinUser()
    val userStatus = userInfo.userStatus!!
    if (userStatus.loginStatus != WepinLoginStatus.COMPLETE) {
        //Wepin Register 코드..
    }
}
```

## logoutWepin

```kotlin
suspend fun logoutWepin(): Boolean
```

위핀에 로그인한 사용자를 로그아웃 합니다.

**Parameters**

* None

**Returns**

* **\<Boolean>**

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
coroutineScope.launch {
    wepinLogin.logoutWepin()
}
```

## getSignForLogin

```kotlin
fun getSignForLogin(privateKeyHex: String, message: String): String
```

발급자를 확인하기 위한 서명을 생성합니다. 주로 ID Token 및 Access Token과 같은 로그인 관련 정보를 위한 서명을 생성하는데 사용합니다.

**Parameters**

* **privateKey** `<String>`\
  명 생성에 사용되는 인증 키
* **message** `<String>`\
  서명될 메시지 또는 페이로드

{% hint style="info" %}
서명에 사용할 키는 [위핀 워크스페이스](https://workspace.wepin.io/login)에서 발급 받을 수 있습니다. 개발 도구 메뉴에서 로그인 탭의 인증키 발급 받기를 클릭하여 인증키를 확인하세요.
{% endhint %}

**Returns**

* **\<String>** - 생성된 서명

{% hint style="info" %}
인증키(**privateKey**)는 반드시 안전하게 보관되어야 하며, 외부에 노출되지 않도록 주의해야 합니다. 보안과 민감한 정보 보호를 위해 `getSignForLogin()` 메서드는 프론트엔드가 아닌 백엔드에서 실행하는 것이 권장됩니다. 서명 생성 방법에 대해서는 [문서](https://github.com/WepinWallet/wepin-web-sdk-v1/blob/main/packages/login/SignatureGenerationMethods.md)를 참고하세요.
{% endhint %}

**Exception**

* [WepinError](#wepinerror)

**Example**

```kotlin
wepinLogin.getSignForLogin(
    privateKeyHex = "private key", 
    message = "idtokenoraccesstoken"
) 
```

## finalize

```kotlin
fun finalize()
```

WepinLoginLibrary를 종료합니다.

**Parameters**

* None

**Returns**

* None

**Exception**

* [WepinError](#wepinerror)

**Example**

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

## 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.                                                                                                                                           |