@novastera-oss/nitro-metamask 0.6.3 → 0.7.2

package/android/src/main/java/io/metamask/androidsdk/ErrorType.kt

@@ -0,0 +1,41 @@
+package io.metamask.androidsdk
+
+enum class ErrorType(val code: Int) {
+    // Ethereum Provider
+    USER_REJECTED_REQUEST(4001), // Ethereum Provider User Rejected Request
+    UNAUTHORISED_REQUEST(4100), // Ethereum Provider User Rejected Request
+    UNSUPPORTED_METHOD(4200), // Ethereum Provider Unsupported Method
+    DISCONNECTED(4900), // Ethereum Provider Not Connected
+    CHAIN_DISCONNECTED(4901), // Ethereum Provider Chain Not Connected
+    UNRECOGNIZED_CHAIN_ID(4902), // Unrecognized chain ID. Try adding the chain using wallet_ADD_ETHEREUM_CHAIN first
+
+    // Ethereum RPC
+    INVALID_INPUT(-32000), // JSON RPC 2.0 Server error
+    TRANSACTION_REJECTED(-32003), // Ethereum JSON RPC Transaction Rejected
+    INVALID_REQUEST(-32600), // JSON RPC 2.0 Invalid Request
+    INVALID_METHOD_PARAMETERS(-32602), // JSON RPC 2.0 Invalid Parameters
+    SERVER_ERROR(-32603), // Could be one of many outcomes
+    PARSE_ERROR(-32700), // JSON RPC 2.0 Parse error
+    UNKNOWN_ERROR(-1); // Check RequestError.code instead
+
+    companion object {
+        fun message(code: Int): String {
+
+            return when(values().firstOrNull { it.code == code }) {
+                USER_REJECTED_REQUEST -> "User rejected request"
+                UNAUTHORISED_REQUEST -> "Request not authorised"
+                UNSUPPORTED_METHOD -> "Ethereum provider unsupported method"
+                DISCONNECTED -> "Ethereum provider not connected"
+                CHAIN_DISCONNECTED -> "Ethereum provider chain not connected"
+                UNRECOGNIZED_CHAIN_ID -> "Unrecognized chain ID. Try adding the chain using ADD_ETHEREUM_CHAIN first"
+                INVALID_INPUT -> "JSON RPC 2.0 Server error"
+                TRANSACTION_REJECTED -> "Ethereum transaction rejected"
+                INVALID_METHOD_PARAMETERS -> "JSON RPC 2.0 invalid parameters"
+                INVALID_REQUEST -> "Invalid request"
+                SERVER_ERROR -> "Server error"
+                PARSE_ERROR -> "Parse error"
+                else -> "The request failed"
+            }
+        }
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/Ethereum.kt

@@ -0,0 +1,328 @@
+package io.metamask.androidsdk
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+import java.lang.ref.WeakReference
+
+private const val METAMASK_DEEPLINK = "https://metamask.app.link"
+private const val METAMASK_BIND_DEEPLINK = "$METAMASK_DEEPLINK/bind"
+
+class Ethereum(
+    private val context: Context,
+    private val dappMetadata: DappMetadata,
+    sdkOptions: SDKOptions? = null,
+    private val logger: Logger = DefaultLogger,
+    private val communicationClientModule: CommunicationClientModuleInterface = CommunicationClientModule(context)
+) : EthereumEventCallback {
+
+    private var connectRequestSent = false
+
+    val communicationClient: CommunicationClient? by lazy {
+        communicationClientModule.provideCommunicationClient(this)
+    }
+
+    private val storage = communicationClientModule.provideKeyStorage()
+
+    // Ethereum LiveData
+    private val _ethereumState = MutableLiveData(EthereumState("", "", ""))
+    private val currentEthereumState: EthereumState
+        get() = checkNotNull(ethereumState.value)
+    val ethereumState: LiveData<EthereumState> get() = _ethereumState
+
+    private var cachedChainId = ""
+    private var cachedAccount = ""
+
+    var selectedAddress: String = ethereumState.value?.selectedAddress.takeIf { !it.isNullOrEmpty() } ?: cachedAccount
+    var chainId: String = ethereumState.value?.chainId.takeIf { !it.isNullOrEmpty() } ?: cachedChainId
+
+    var enableDebug: Boolean = true
+        set(value) {
+            field = value
+            communicationClient?.enableDebug = value
+        }
+
+    init {
+        runBlocking { fetchCachedSession() }
+    }
+
+    private suspend fun fetchCachedSession() {
+        withContext(Dispatchers.IO) {
+            try {
+                val account = storage.getValue(key = SessionManager.SESSION_ACCOUNT_KEY, file = SessionManager.SESSION_CONFIG_FILE)
+                val chainId = storage.getValue(key = SessionManager.SESSION_CHAIN_ID_KEY, file = SessionManager.SESSION_CONFIG_FILE)
+                if (account != null && chainId != null) {
+                    cachedChainId = chainId
+                    cachedAccount = account
+                    _ethereumState.postValue(
+                        currentEthereumState.copy(
+                            selectedAddress = account,
+                            chainId = chainId,
+                            sessionId = communicationClient?.sessionId ?: ""
+                        )
+                    )
+                }
+            } catch (e: Exception) {
+                e.localizedMessage?.let { logger.error(it) }
+            }
+        }
+    }
+
+    fun enableDebug(enable: Boolean) = apply {
+        this.enableDebug = enable
+    }
+
+    private var sessionDuration: Long = SessionManager.DEFAULT_SESSION_DURATION
+
+    override fun updateAccount(account: String) {
+        logger.log("Ethereum:: Selected account changed: $account")
+        _ethereumState.postValue(
+            currentEthereumState.copy(
+                selectedAddress = account,
+                sessionId = communicationClient?.sessionId ?: ""
+            )
+        )
+        if (account.isNotEmpty()) {
+            selectedAddress = account
+            storage.putValue(account, key = SessionManager.SESSION_ACCOUNT_KEY, SessionManager.SESSION_CONFIG_FILE)
+        }
+    }
+
+    override fun updateChainId(newChainId: String) {
+        logger.log("Ethereum:: ChainId changed: $newChainId")
+        _ethereumState.postValue(
+            currentEthereumState.copy(
+                chainId = newChainId,
+                sessionId = communicationClient?.sessionId ?: ""
+            )
+        )
+        if (newChainId.isNotEmpty()) {
+            chainId = newChainId
+            storage.putValue(newChainId, key = SessionManager.SESSION_CHAIN_ID_KEY, SessionManager.SESSION_CONFIG_FILE)
+        }
+    }
+
+    fun updateSessionDuration(duration: Long = SessionManager.DEFAULT_SESSION_DURATION) = apply {
+        sessionDuration = duration
+        communicationClient?.updateSessionDuration(duration)
+    }
+
+    fun clearSession() {
+        disconnect(true)
+        storage.clear(SessionManager.SESSION_CONFIG_FILE)
+    }
+
+    fun connect(callback: ((Result) -> Unit)? = null) {
+        connectRequestSent = true
+
+        val error = dappMetadata.validationError
+        if (error != null) {
+            callback?.invoke(Result.Error(error))
+            return
+        }
+
+        logger.log("Ethereum:: connecting...")
+        communicationClient?.dappMetadata = dappMetadata
+        communicationClient?.ethereumEventCallbackRef = WeakReference(this)
+        communicationClient?.updateSessionDuration(sessionDuration)
+
+        _ethereumState.postValue(
+            currentEthereumState.copy(
+                selectedAddress = "",
+                chainId = ""
+            )
+        )
+        requestAccounts(callback)
+    }
+
+    fun connectWith(request: EthereumRequest, callback: ((Result) -> Unit)? = null) {
+        logger.log("Ethereum:: connecting with ${request.method}...")
+        connectRequestSent = true
+        communicationClient?.dappMetadata = dappMetadata
+        communicationClient?.ethereumEventCallbackRef = WeakReference(this)
+        communicationClient?.updateSessionDuration(sessionDuration)
+
+        _ethereumState.postValue(
+            currentEthereumState.copy(
+                selectedAddress = "",
+                chainId = ""
+            )
+        )
+        val sendRequest: EthereumRequest = if (request.method == EthereumMethod.METAMASK_CONNECT_WITH.value) {
+            request
+        } else {
+            EthereumRequest(
+                method = EthereumMethod.METAMASK_CONNECT_WITH.value,
+                params = listOf(request)
+            )
+        }
+        sendConnectRequest(sendRequest, callback)
+    }
+
+    fun connectSign(message: String, callback: ((Result) -> Unit)? = null) {
+        connectRequestSent = true
+        communicationClient?.dappMetadata = dappMetadata
+        communicationClient?.ethereumEventCallbackRef = WeakReference(this)
+        communicationClient?.updateSessionDuration(sessionDuration)
+
+        _ethereumState.postValue(
+            currentEthereumState.copy(
+                selectedAddress = "",
+                chainId = ""
+            )
+        )
+        val connectSignRequest = EthereumRequest(
+            method = EthereumMethod.METAMASK_CONNECT_SIGN.value,
+            params = listOf(message)
+        )
+        sendConnectRequest(connectSignRequest, callback)
+    }
+
+    private fun ethereumRequest(method: EthereumMethod, params: Any?, callback: ((Result) -> Unit)?) {
+        sendRequest(EthereumRequest(method = method.value, params = params), callback)
+    }
+
+    fun getChainId(callback: ((Result) -> Unit)?) {
+        if (connectRequestSent) {
+            ethereumRequest(method = EthereumMethod.ETH_CHAIN_ID, params = null, callback)
+        } else {
+            callback?.invoke(Result.Success.Item(cachedChainId))
+        }
+    }
+
+    fun getEthAccounts(callback: ((Result) -> Unit)?) {
+        if (connectRequestSent) {
+            ethereumRequest(method = EthereumMethod.ETH_ACCOUNTS, params = null, callback)
+        } else {
+            callback?.invoke(Result.Success.Item(cachedAccount))
+        }
+    }
+
+    fun getEthBalance(address: String, block: String, callback: ((Result) -> Unit)? = null) {
+        ethereumRequest(EthereumMethod.ETH_GET_BALANCE, params = listOf(address, block), callback)
+    }
+
+    fun getEthBlockNumber(callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.ETH_BLOCK_NUMBER, params = null, callback)
+    }
+
+    fun getEthEstimateGas(callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.ETH_ESTIMATE_GAS, params = null, callback)
+    }
+
+    fun getWeb3ClientVersion(callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.WEB3_CLIENT_VERSION, params = listOf<String>(), callback)
+    }
+
+    fun personalSign(message: String, address: String, callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.PERSONAL_SIGN, params = listOf(address, message), callback)
+    }
+
+    fun ethSignTypedDataV4(typedData: Any, address: String, callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.ETH_SIGN_TYPED_DATA_V4, params = listOf(address, typedData), callback)
+    }
+
+    fun sendTransaction(from: String, to: String, value: String, callback: ((Result) -> Unit)?) {
+        ethereumRequest(
+            method = EthereumMethod.ETH_SEND_TRANSACTION,
+            params = listOf(mutableMapOf("from" to from, "to" to to, "value" to value)),
+            callback
+        )
+    }
+
+    fun sendRawTransaction(signedTransaction: String, callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.ETH_SEND_RAW_TRANSACTION, params = listOf(signedTransaction), callback)
+    }
+
+    fun getBlockTransactionCountByNumber(blockNumber: String, callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.ETH_GET_BLOCK_TRANSACTION_COUNT_BY_NUMBER, params = listOf(blockNumber), callback)
+    }
+
+    fun getBlockTransactionCountByHash(blockHash: String, callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.ETH_GET_BLOCK_TRANSACTION_COUNT_BY_HASH, params = listOf(blockHash), callback)
+    }
+
+    fun getTransactionCount(address: String, tagOrblockNumber: String, callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.ETH_GET_TRANSACTION_COUNT, params = listOf(address, tagOrblockNumber), callback)
+    }
+
+    fun switchEthereumChain(targetChainId: String, callback: ((Result) -> Unit)?) {
+        ethereumRequest(method = EthereumMethod.SWITCH_ETHEREUM_CHAIN, params = listOf(mapOf("chainId" to targetChainId)), callback)
+    }
+
+    private fun sendConnectRequest(request: EthereumRequest, callback: ((Result) -> Unit)?) {
+        sendRequest(request, callback)
+    }
+
+    fun disconnect(clearSession: Boolean = false) {
+        logger.log("Ethereum:: disconnecting...")
+        connectRequestSent = false
+        communicationClient?.resetState()
+        communicationClient?.unbindService()
+
+        if (clearSession) {
+            communicationClient?.clearSession {
+                resetEthereumState()
+            }
+        } else {
+            resetEthereumState()
+        }
+    }
+
+    private fun resetEthereumState() {
+        _ethereumState.postValue(
+            currentEthereumState.copy(
+                selectedAddress = "",
+                sessionId = communicationClient?.sessionId ?: "",
+                chainId = ""
+            )
+        )
+    }
+
+    private fun requestChainId() {
+        val chainIdRequest = EthereumRequest(method = EthereumMethod.ETH_CHAIN_ID.value)
+        sendRequest(chainIdRequest)
+    }
+
+    private fun requestAccounts(callback: ((Result) -> Unit)? = null) {
+        logger.log("Ethereum:: Requesting ethereum accounts")
+        connectRequestSent = true
+        val accountsRequest = EthereumRequest(method = EthereumMethod.ETH_REQUEST_ACCOUNTS.value)
+        sendConnectRequest(accountsRequest, callback)
+        requestChainId()
+    }
+
+    fun sendRequest(request: RpcRequest, callback: ((Result) -> Unit)? = null) {
+        logger.log("Ethereum:: Sending request $request")
+
+        if (!connectRequestSent && selectedAddress.isEmpty()) {
+            requestAccounts {
+                sendRequest(request, callback)
+            }
+            return
+        }
+
+        communicationClient?.sendRequest(request) { response ->
+            callback?.invoke(response)
+        }
+        if (EthereumMethod.requiresAuthorisation(request.method)) {
+            openMetaMask()
+        }
+    }
+
+    fun sendRequestBatch(requests: List<EthereumRequest>, callback: ((Result) -> Unit)? = null) {
+        val batchRequest = AnyRequest(method = EthereumMethod.METAMASK_BATCH.value, params = requests)
+        sendRequest(batchRequest, callback)
+    }
+
+    private fun openMetaMask() {
+        val intent = Intent(Intent.ACTION_VIEW, Uri.parse(METAMASK_BIND_DEEPLINK))
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        context.startActivity(intent)
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/EthereumEventCallback.kt

@@ -0,0 +1,6 @@
+package io.metamask.androidsdk
+
+interface EthereumEventCallback {
+    fun updateAccount(account: String)
+    fun updateChainId(newChainId: String)
+}

package/android/src/main/java/io/metamask/androidsdk/EthereumMethod.kt

@@ -0,0 +1,80 @@
+package io.metamask.androidsdk
+
+enum class EthereumMethod(val value: String) {
+    ETH_SIGN("eth_sign"),
+    WEB3_SHA("web3_sha3"),
+    ETH_CALL("eth_call"),
+    ETH_CHAIN_ID("eth_chainId"),
+    ETH_GET_CODE("eth_getCode"),
+    ETH_ACCOUNTS("eth_accounts"),
+    ETH_GAS_PRICE("eth_gasPrice"),
+    PERSONAL_SIGN("personal_sign"),
+    ETH_GET_BALANCE("eth_getBalance"),
+    WATCH_ASSET("wallet_watchAsset"),
+    ETH_BLOCK_NUMBER("eth_blockNumber"),
+    ETH_ESTIMATE_GAS("eth_estimateGas"),
+    ETH_GET_STORAGE_AT("eth_getStorageAt"),
+    ETH_SIGN_TYPED_DATA("eth_signTypedData"),
+    ETH_GET_BLOCK_BY_HASH("eth_getBlockByHash"),
+    WEB3_CLIENT_VERSION("web3_clientVersion"),
+    ETH_REQUEST_ACCOUNTS("eth_requestAccounts"),
+    ETH_SIGN_TRANSACTION("eth_signTransaction"),
+    ETH_SEND_TRANSACTION("eth_sendTransaction"),
+    ETH_SIGN_TYPED_DATA_V3("eth_signTypedData_v3"),
+    ETH_SIGN_TYPED_DATA_V4("eth_signTypedData_v4"),
+    ADD_ETHEREUM_CHAIN("wallet_addEthereumChain"),
+    METAMASK_BATCH("metamask_batch"),
+    METAMASK_OPEN("metamask_open"),
+    PERSONAL_EC_RECOVER("personal_ecRecover"),
+    WALLET_REVOKE_PERMISSIONS("wallet_revokePermissions"),
+    WALLET_REQUEST_PERMISSIONS("wallet_requestPermissions"),
+    WALLET_GET_PERMISSIONS("wallet_getPermissions"),
+    METAMASK_CONNECT_WITH("metamask_connectwith"),
+    METAMASK_CONNECT_SIGN("metamask_connectSign"),
+    METAMASK_CHAIN_CHANGED("metamask_chainChanged"),
+    ETH_SEND_RAW_TRANSACTION("eth_sendRawTransaction"),
+    SWITCH_ETHEREUM_CHAIN("wallet_switchEthereumChain"),
+    ETH_GET_TRANSACTION_COUNT("eth_getTransactionCount"),
+    METAMASK_ACCOUNTS_CHANGED("metamask_accountsChanged"),
+    ETH_GET_TRANSACTION_BY_HASH("eth_getTransactionByHash"),
+    ETH_GET_TRANSACTION_RECEIPT("eth_getTransactionReceipt"),
+    GET_METAMASK_PROVIDER_STATE("metamask_getProviderState"),
+    ETH_GET_BLOCK_TRANSACTION_COUNT_BY_HASH("eth_getBlockTransactionCountByHash"),
+    ETH_GET_BLOCK_TRANSACTION_COUNT_BY_NUMBER("eth_getBlockTransactionCountByNumber"),
+    UNKNOWN("unknown");
+
+    companion object {
+        fun hasMethod(method: String): Boolean {
+            return enumValues<EthereumMethod>()
+                .toList()
+                .map { it.value }
+                .contains(method)
+        }
+
+        fun requiresAuthorisation(method: String): Boolean {
+            val authorisationMethods: List<String> = listOf(
+                ETH_SIGN, WATCH_ASSET, PERSONAL_SIGN, METAMASK_BATCH, WALLET_GET_PERMISSIONS, WALLET_REVOKE_PERMISSIONS,
+                ADD_ETHEREUM_CHAIN, SWITCH_ETHEREUM_CHAIN, METAMASK_CONNECT_WITH, WALLET_REQUEST_PERMISSIONS,
+                ETH_SEND_TRANSACTION, ETH_SIGN_TRANSACTION, ETH_REQUEST_ACCOUNTS, METAMASK_CONNECT_SIGN, PERSONAL_EC_RECOVER,
+                ETH_SIGN_TYPED_DATA, ETH_SIGN_TYPED_DATA_V3, ETH_SIGN_TYPED_DATA_V4, ETH_ACCOUNTS, METAMASK_OPEN
+            ).map { it.value }
+
+            return authorisationMethods.contains(method)
+        }
+
+        fun isReadOnly(method: String): Boolean {
+            return !requiresAuthorisation(method)
+        }
+
+        fun isResultMethod(method: String): Boolean {
+            val resultMethods: List<String> = listOf(
+                ETH_SIGN, ETH_CHAIN_ID, PERSONAL_SIGN, METAMASK_CONNECT_WITH, WALLET_GET_PERMISSIONS,
+                ADD_ETHEREUM_CHAIN, SWITCH_ETHEREUM_CHAIN, METAMASK_BATCH, WALLET_REQUEST_PERMISSIONS,
+                ETH_SIGN_TRANSACTION, ETH_SEND_TRANSACTION, METAMASK_CONNECT_SIGN, WALLET_REVOKE_PERMISSIONS,
+                WATCH_ASSET, ETH_REQUEST_ACCOUNTS, GET_METAMASK_PROVIDER_STATE,ETH_ACCOUNTS,
+                ETH_SIGN_TYPED_DATA, ETH_SIGN_TYPED_DATA_V3, ETH_SIGN_TYPED_DATA_V4,
+            ).map { it.value }
+            return resultMethods.contains(method)
+        }
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/EthereumRequest.kt

@@ -0,0 +1,7 @@
+package io.metamask.androidsdk
+
+data class EthereumRequest(
+    override var id: String = TimeStampGenerator.timestamp(),
+    override val method: String,
+    override val params: Any? = null
+) : RpcRequest()

package/android/src/main/java/io/metamask/androidsdk/EthereumState.kt

@@ -0,0 +1,7 @@
+package io.metamask.androidsdk
+
+data class EthereumState(
+    val chainId: String,
+    val sessionId: String,
+    val selectedAddress: String
+)

package/android/src/main/java/io/metamask/androidsdk/KeyExchange.kt

@@ -0,0 +1,77 @@
+package io.metamask.androidsdk
+
+import io.metamask.androidsdk.KeyExchangeMessageType.*
+
+data class KeyExchangeMessage(
+    val type: String,
+    val publicKey: String?
+    )
+
+class KeyExchange(private val crypto: Encryption = Crypto(), private val logger: Logger = DefaultLogger) {
+    companion object {
+        const val TYPE = "type"
+        const val PUBLIC_KEY = "public_key"
+    }
+
+    private var privateKey: String? = null
+    var publicKey: String? = null
+    private var theirPublicKey: String? = null
+    private var isKeysExchanged = false
+
+    init {
+        reset()
+        crypto.onInitialized = {
+            reset()
+        }
+    }
+
+    private fun setIsKeysExchanged(newValue: Boolean) {
+        synchronized(this) {
+            isKeysExchanged = newValue
+        }
+    }
+
+    fun keysExchanged(): Boolean {
+        synchronized(this) {
+            return isKeysExchanged
+        }
+    }
+
+    fun reset() {
+        privateKey = crypto.generatePrivateKey()
+        privateKey?.let {
+            publicKey = crypto.publicKey(it)
+        }
+        setIsKeysExchanged(false)
+        theirPublicKey = null
+    }
+
+    fun encrypt(message: String): String {
+        val key: String = theirPublicKey ?: throw NullPointerException("theirPublicKey is null")
+        return crypto.encrypt(key, message)
+    }
+
+    fun decrypt(message: String): String {
+        val key: String = privateKey ?: throw NullPointerException("privateKey is null")
+        return crypto.decrypt(key, message)
+    }
+
+    fun complete() {
+        logger.log("KeyExchange:: Key exchange complete")
+        setIsKeysExchanged(true)
+    }
+
+    fun nextKeyExchangeMessage(current: KeyExchangeMessage): KeyExchangeMessage? {
+        current.publicKey?.let {
+            theirPublicKey = it
+        }
+
+        return when(current.type) {
+            KEY_HANDSHAKE_START.name -> KeyExchangeMessage(KEY_HANDSHAKE_SYN.name, publicKey)
+            KEY_HANDSHAKE_SYN.name -> KeyExchangeMessage(KEY_HANDSHAKE_SYNACK.name, publicKey)
+            KEY_HANDSHAKE_SYNACK.name -> KeyExchangeMessage(KEY_HANDSHAKE_ACK.name, publicKey)
+            KEY_HANDSHAKE_ACK.name -> null
+            else -> null
+        }
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/KeyExchangeMessageType.kt

@@ -0,0 +1,20 @@
+package io.metamask.androidsdk
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class KeyExchangeMessageType {
+    @SerialName("none")
+    NONE,
+    @SerialName("key_handshake_start")
+    KEY_HANDSHAKE_START,
+    @SerialName("key_handshake_check")
+    KEY_HANDSHAKE_CHECK,
+    @SerialName("key_exchange_SYN")
+    KEY_HANDSHAKE_SYN,
+    @SerialName("key_exchange_SYNACK")
+    KEY_HANDSHAKE_SYNACK,
+    @SerialName("key_exchange_ACK")
+    KEY_HANDSHAKE_ACK
+}