@onekeyfe/react-native-lite-card 1.0.0

package/android/src/main/java/so/onekey/app/wallet/onekeyLite/nfc/CommandGenerator.kt

@@ -0,0 +1,178 @@
+package so.onekey.app.wallet.onekeyLite.nfc
+
+import com.google.gson.JsonObject
+import com.google.gson.JsonParser
+import org.haobtc.onekey.card.gpchannel.GPChannelNatives.nativeGPCParseAPDUResponse
+import org.haobtc.onekey.card.gpchannel.GPChannelNatives.nativeGPCParseSafeAPDUResponse
+import so.onekey.app.wallet.nfc.NFCExceptions
+import so.onekey.app.wallet.onekeyLite.entitys.APDUParam
+import so.onekey.app.wallet.onekeyLite.entitys.CardResponse
+import so.onekey.app.wallet.onekeyLite.entitys.SendResponse
+import so.onekey.app.wallet.utils.Utils
+
+enum class AppleCardType(val aid: String, val prefixSN: String) {
+    V1("D156000132834001", "OKLFT"),
+    V2("6f6e656b65792e6261636b757001", "OKLFB"),
+}
+
+enum class CommandArea(val code: String) {
+    None("none"), BackupApplet("backup"), PrimarySafety("master");
+
+    companion object {
+        fun parse(code: String): CommandArea {
+            return when (code) {
+                "backup" -> BackupApplet
+                "master" -> PrimarySafety
+                else -> None
+            }
+        }
+    }
+}
+
+enum class CommandType(val code: String) {
+    SELECT_BACKUP_APPLET("select_backup_applet"),
+    SELECT_PRIMARY_SAFETY("select_primary_safety"),
+    GET_BACKUP_STATUS("get_backup_status"),
+    GET_PIN_STATUS("get_pin_status"),
+    GET_SERIAL_NUMBER("get_serial_number"),
+    GET_PIN_RETRY_COUNT("get_pin_retry_count"),
+    RESET_CARD("reset_card"),
+    VERIFY_PIN("verify_pin"),
+    SETUP_NEW_PIN("setup_new_pin"),
+    CHANGE_PIN("change_pin"),
+    BACKUP_DATA("backup_data"),
+    EXPORT_DATA("export_data"),
+    VERIFY_CERTIFICATE("verify_certificate"),
+    VERIFY_AUTH_DATA("verify_auth_data"),
+}
+
+class Command(
+    private val cardType: AppleCardType,
+    val area: CommandArea,
+    val command: String,
+    private val ignoreSafeChannel: Boolean,
+    private val useSafeChannel: Boolean,
+    private val useSafeChannelWhenOpen: Boolean,
+    private val hasOpenSafeChannel: Boolean,
+    val data: String,
+) {
+    private fun beforeConnecting(connection: Connection) {
+        val needOpenSafeChannel = useSafeChannel || (useSafeChannelWhenOpen && hasOpenSafeChannel)
+        val needCloseSafeChannel =
+            (!useSafeChannel && !(useSafeChannelWhenOpen && hasOpenSafeChannel))
+
+        if (!ignoreSafeChannel && needCloseSafeChannel) {
+            if (hasOpenSafeChannel) connection.resetSecureChannel()
+        }
+
+        if (area == CommandArea.BackupApplet) {
+            if (connection.getCurrentCommandArea() != CommandArea.BackupApplet) {
+                connection.selectBackupApplet(cardType)
+            }
+        } else if (area == CommandArea.PrimarySafety) {
+            if (connection.getCurrentCommandArea() != CommandArea.PrimarySafety) {
+                connection.selectPrimarySafety()
+            }
+        }
+
+        if (!ignoreSafeChannel && needOpenSafeChannel) {
+            val res = connection.openSafeChannel()
+            if (!res) throw NFCExceptions.InterruptException()
+        }
+    }
+
+    private fun splitHex(hex: String): List<String> {
+        val result = mutableListOf<String>()
+        for (i in hex.indices step 2) {
+            result.add(hex.substring(i, i + 2))
+        }
+        return result
+    }
+
+    private fun buildApdu(): String {
+        val commandByteArray = splitHex(command).map { it.toLong(16) }.toLongArray()
+        return GPCAPDUGenerator.buildGPCAPDU(
+            APDUParam(commandByteArray, data),
+            useSafeChannel || (useSafeChannelWhenOpen && hasOpenSafeChannel)
+        )
+    }
+
+    private fun parseResponse(response: String): String {
+        return if (useSafeChannel || (useSafeChannelWhenOpen && hasOpenSafeChannel)) {
+            nativeGPCParseSafeAPDUResponse(response)
+        } else {
+            nativeGPCParseAPDUResponse(response)
+        }
+    }
+
+    fun send(connection: Connection): SendResponse {
+        beforeConnecting(connection)
+        // buildApdu && parseResponse Use in pairs
+        val apdu = buildApdu()
+        val result = Connection.send(connection.isoDep, apdu)
+        val resultObject = CardResponse.objectFromData(parseResponse(result.rawResponse))
+        result.result = resultObject?.response ?: ""
+        return result
+    }
+}
+
+class CommandGenerator {
+    companion object {
+        private fun readConfig(): JsonObject {
+            val context = Utils.getApp()
+            val config = context.assets.open("config/command.json")
+            config.use {
+                val json = it.bufferedReader().use { it.readText() }
+                return JsonParser.parseString(json).asJsonObject
+            }
+        }
+
+        val instanceConfig by lazy(LazyThreadSafetyMode.NONE) {
+            readConfig()
+        }
+    }
+
+    fun generalCommand(
+        cardType: AppleCardType,
+        type: CommandType,
+        hasOpenSafeChannel: Boolean,
+        data: String? = null
+    ): Command {
+
+        val config = when (cardType) {
+            AppleCardType.V1 -> instanceConfig.getAsJsonObject(type.code).getAsJsonObject("v1")
+            AppleCardType.V2 -> instanceConfig.getAsJsonObject(type.code).getAsJsonObject("v2")
+        }
+
+        val area = if (config.has("area")) {
+            CommandArea.parse(config["area"].asString)
+        } else {
+            CommandArea.None
+        }
+        val ignoreSafeChannel =
+            config.has("ignoreSafeChannel") && config["ignoreSafeChannel"].asBoolean
+        val useSafeChannel = config.has("useSafeChannel") && config["useSafeChannel"].asBoolean
+        val useSafeChannelWhenOpen =
+            config.has("useSafeChannelWhenOpen") && config["useSafeChannelWhenOpen"].asBoolean
+        val needData = config.has("needData") && config["needData"].asBoolean
+        val command = if (config.has("command")) {
+            config["command"].asString
+        } else {
+            throw Exception("command not found")
+        }
+
+        if (needData && data == null) throw Exception("data is null")
+
+        return Command(
+            cardType = cardType,
+            area = area,
+            command = command,
+            ignoreSafeChannel = ignoreSafeChannel,
+            useSafeChannel = useSafeChannel,
+            useSafeChannelWhenOpen = useSafeChannelWhenOpen,
+            hasOpenSafeChannel = hasOpenSafeChannel,
+            data = data ?: ""
+        )
+    }
+
+}

package/android/src/main/java/so/onekey/app/wallet/onekeyLite/nfc/Connection.kt

@@ -0,0 +1,430 @@
+package so.onekey.app.wallet.onekeyLite.nfc
+
+import android.nfc.tech.IsoDep
+import org.haobtc.onekey.card.gpchannel.GPChannelNatives
+import org.haobtc.onekey.card.gpchannel.GPChannelNatives.nativeGPCFinalize
+import so.onekey.app.wallet.keys.KeysNativeProvider
+import so.onekey.app.wallet.nfc.NFCExceptions
+import so.onekey.app.wallet.onekeyLite.NfcConstant
+import so.onekey.app.wallet.onekeyLite.entitys.*
+import so.onekey.app.wallet.onekeyLite.nfc.GPCAPDUGenerator.buildGPCAPDU
+import so.onekey.app.wallet.onekeyLite.nfc.GPCAPDUGenerator.combCommand
+import so.onekey.app.wallet.utils.HexUtils
+import so.onekey.app.wallet.utils.HexUtils.byteArr2HexStr
+import so.onekey.app.wallet.utils.HexUtils.hexString2Bytes
+import so.onekey.app.wallet.utils.LogUtil.printLog
+import so.onekey.app.wallet.utils.Utils
+import java.io.IOException
+
+class Connection(val isoDep: IsoDep, private val mCommandGenerator: CommandGenerator) {
+    companion object {
+        private const val TAG = "Connection"
+
+        @JvmStatic
+        private fun connect(isoDep: IsoDep?) {
+            if (isoDep?.isConnected == false) {
+                isoDep.connect()
+                isoDep.timeout = 15000
+            }
+        }
+
+        @JvmStatic
+        fun send(isoDep: IsoDep, request: String?): SendResponse {
+            try {
+                connect(isoDep)
+                val response = isoDep.transceive(hexString2Bytes(request)) ?: byteArrayOf(
+                    0xFF.toByte(), 0xFF.toByte()
+                )
+                val resp: ByteArray = if (response.size > 2) {
+                    response.copyOfRange(0, response.size - 2)
+                } else byteArrayOf()
+                val sw1 = response[response.size - 2]
+                val sw2 = response[response.size - 1]
+
+                return SendResponse(byteArr2HexStr(response), sw1, sw2, byteArr2HexStr(resp))
+            } catch (e: IOException) {
+                e.printStackTrace()
+                return SendResponse("0xFFFF", 0xFF.toByte(), 0xFF.toByte())
+            }
+        }
+    }
+
+    private var mCardType: AppleCardType = AppleCardType.V2
+    private var mCardSerialNumber: String = NfcConstant.NOT_MATCH_DEVICE
+    private var hasOpenSafeChannel: Boolean = false
+    private var hasSetupPin: Boolean = false
+    private var hasBackup: Boolean = false
+    private var mCommandArea = CommandArea.None
+
+    init {
+        readCardInfo()
+    }
+
+    fun getCardType(): AppleCardType {
+        return mCardType
+    }
+
+    fun getCurrentCommandArea(): CommandArea {
+        return mCommandArea
+    }
+
+    fun selectPrimarySafety(): Boolean {
+        printLog(TAG, "---> selectPrimarySafety begin")
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.SELECT_PRIMARY_SAFETY, hasOpenSafeChannel,
+        )
+        val res = command.send(this)
+        printLog(
+            TAG, "<--- selectPrimarySafety end: ${res.getCode()} ${res.data} area:${mCommandArea}"
+        )
+
+        if (res.isSuccess() && !res.isEmptyData()) {
+            mCommandArea = CommandArea.PrimarySafety
+            return true
+        }
+        return false
+    }
+
+    fun selectBackupApplet(cardType: AppleCardType?): Boolean {
+        printLog(TAG, "---> selectApplet begin")
+        val command = mCommandGenerator.generalCommand(
+            cardType ?: mCardType,
+            CommandType.SELECT_BACKUP_APPLET,
+            hasOpenSafeChannel,
+            cardType?.aid ?: mCardType.aid
+        )
+        val res = command.send(this)
+
+        printLog(TAG, "<--- selectApplet end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        if (res.isSuccess()) {
+            mCommandArea = CommandArea.BackupApplet
+            return true
+        }
+        return false
+    }
+
+    private fun getDeviceCertificate(): ParsedCertInfo? {
+        printLog(TAG, "---> getDeviceCertificate begin")
+        // #1.NFC:GET CERT.SD.ECKA 获取智能卡证书
+        val apdu = buildGPCAPDU(APDUParam(0x80, 0xCA, 0xBF, 0x21, "A60483021518"))
+        val rawCert = send(isoDep, apdu)
+        printLog(
+            TAG,
+            "<--- getDeviceCertificate end: ${rawCert.getCode()} ${rawCert.data} area:${mCommandArea}"
+        )
+
+        val cert = GPChannelNatives.nativeGPCTLVDecode(rawCert.data)
+        val certificate = CardResponse.objectFromData(cert).response
+
+        val certInfo = GPChannelNatives.nativeGPCParseCertificate(certificate)
+        return ParsedCertInfo.objectFromData(certInfo)
+    }
+
+    fun openSafeChannel(): Boolean {
+        printLog(TAG, "---> openSafeChannel begin")
+
+        if (hasOpenSafeChannel) {
+            printLog(TAG, "<--- has open safe channel")
+            return true
+        }
+
+        printLog(TAG, "0. ---> getDeviceCertificate begin")
+        val certInfo = getDeviceCertificate() ?: return false
+        printLog(TAG, "0. <--- getDeviceCertificate end: ${certInfo.subjectID}")
+
+        printLog(TAG, "1. ---> nativeGPCInitialize begin")
+        val param = SecureChanelParam.objectFromData(
+        	KeysNativeProvider().getLiteSecureChannelInitParams(Utils.getApp())
+        )
+        param.cardGroupID = certInfo.subjectID
+        printLog(TAG, "nativeGPCInitialize read param done")
+        val initializeStatus = GPChannelNatives.nativeGPCInitialize(param.toString())
+        if (initializeStatus != 0) {
+            return false
+        }
+        printLog(TAG, "1. <--- nativeGPCInitialize end")
+
+        printLog(TAG, "2. ---> Perform security operation begin")
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.VERIFY_CERTIFICATE, hasOpenSafeChannel, param.crt
+        )
+        val securityRes = command.send(this)
+        printLog(
+            TAG,
+            "2. <--- Perform security operation end: ${securityRes.getCode()} ${securityRes.data}"
+        )
+        if (!securityRes.isSuccess()) {
+            return false
+        }
+
+        printLog(TAG, "3. ---> mutual authenticate begin")
+        val authData = GPChannelNatives.nativeGPCBuildMutualAuthData()
+        printLog(TAG, "mutual authenticate data")
+        val authCommand = mCommandGenerator.generalCommand(
+            mCardType, CommandType.VERIFY_AUTH_DATA, hasOpenSafeChannel, authData
+        )
+        val authRes = authCommand.send(this)
+        printLog(TAG, "3. <--- mutual authenticate end")
+        if (authRes.isEmptyData() || !authRes.isSuccess()) {
+            return false
+        }
+
+        printLog(TAG, "4. ---> open secure channel begin")
+        val openStatus = GPChannelNatives.nativeGPCOpenSecureChannel(authRes.result)
+        if (openStatus != 0) {
+            return false
+        }
+        printLog(TAG, "4. <--- open secure channel end")
+
+        printLog(TAG, "<--- openSafeChannel end: Open Secure Channel OK")
+
+        hasOpenSafeChannel = true
+        return true
+    }
+
+    fun resetSecureChannel(): Boolean {
+        printLog(TAG, "---> resetSecureChannel begin")
+        nativeGPCFinalize()
+        hasOpenSafeChannel = false
+        printLog(TAG, "<--- resetSecureChannel end")
+        return true
+    }
+
+    private fun loadBackupStatus(): Boolean {
+        printLog(TAG, "---> getBackupStatus begin")
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.GET_BACKUP_STATUS, hasOpenSafeChannel
+        )
+        val res = command.send(this)
+        printLog(TAG, "<--- getBackupStatus end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        if (!res.isSuccess()) {
+            return false
+        }
+
+        return (res.data == "02").also { hasBackup = it }
+    }
+
+    private fun loadPinStatus(): Boolean {
+        printLog(TAG, "---> getPinStatus begin")
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.GET_PIN_STATUS, hasOpenSafeChannel, "DFFF028105"
+        )
+        val res = command.send(this)
+        printLog(TAG, "<--- getPinStatus end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        if (!res.isSuccess()) {
+            return false
+        }
+
+        val notSetPin = res.data == "02"
+        hasSetupPin = !notSetPin
+        return notSetPin
+    }
+
+    private fun loadSerialNumber(cardType: AppleCardType? = null): String {
+        printLog(TAG, "---> getSerialNumber begin")
+        val command = mCommandGenerator.generalCommand(
+            cardType ?: mCardType, CommandType.GET_SERIAL_NUMBER, hasOpenSafeChannel, "DFFF028101"
+        )
+        val res = command.send(this)
+
+        printLog(TAG, "<--- getSerialNumber end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+        if (!res.isSuccess()) {
+            return NfcConstant.NOT_MATCH_DEVICE
+        }
+
+        return String(hexString2Bytes(res.data)).also {
+            mCardSerialNumber = it
+        }
+    }
+
+    private fun getRetryCount(): Int {
+        printLog(TAG, "---> getRetryNum begin")
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.GET_PIN_RETRY_COUNT, hasOpenSafeChannel, "DFFF028102"
+        )
+        val res = command.send(this)
+
+        printLog(TAG, "<--- getRetryNum end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        if (res.isEmptyData() || !res.isSuccess()) {
+            return NfcConstant.GET_RETRY_NUM_INTERRUPT_STATUS
+        }
+        return res.data?.toInt(16) ?: NfcConstant.GET_RETRY_NUM_INTERRUPT_STATUS
+    }
+
+    private fun readCardInfo() {
+        printLog(TAG, "---> initCard begin")
+        try {
+            val cardTypes = arrayOf(AppleCardType.V1, AppleCardType.V2)
+            for (cardType in cardTypes) {
+                printLog(TAG, "---->> selectApplet: $cardType")
+                val serialNumber = loadSerialNumber(cardType)
+                if (serialNumber.startsWith(cardType.prefixSN)) {
+                    mCardType = cardType
+                    break
+                }
+            }
+        } catch (e: NFCExceptions) {
+            printLog(TAG, " init_channel NFCExceptions-->$e")
+        }
+
+        loadPinStatus()
+        if (mCardType == AppleCardType.V2) {
+            loadBackupStatus()
+        } else {
+            hasBackup = hasSetupPin
+        }
+        printLog(TAG, "<--- initCard end")
+    }
+
+    fun getCardInfo(): CardState {
+        val retryCount = getRetryCount()
+        return CardState(hasBackup, !hasSetupPin, mCardSerialNumber, retryCount)
+    }
+
+    fun getSerialNumber() = mCardSerialNumber
+
+    fun setupNewPin(pin: String): Boolean {
+        printLog(TAG, "---> setupNewPin begin")
+        val pinHex = HexUtils.stringToHexString(pin)
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.SETUP_NEW_PIN, hasOpenSafeChannel, "DFFE0B8204080006$pinHex"
+        )
+        val res = command.send(this)
+        printLog(TAG, "<--- setupNewPin end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        if (!res.isSuccess()) {
+            return false
+        }
+
+        return true
+    }
+
+    fun changePin(oldPin: String, newPin: String?): Int {
+        printLog(TAG, "---> changePin begin")
+        val oldPinHex = HexUtils.stringToHexString(oldPin)
+        val newPinHex = HexUtils.stringToHexString(newPin)
+        val changePinCommand = combCommand(
+            hexString2Bytes("8204"), hexString2Bytes(oldPinHex), hexString2Bytes(newPinHex)
+        )
+        val execCommand = combCommand(hexString2Bytes("DFFE"), changePinCommand)
+
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.CHANGE_PIN, hasOpenSafeChannel, byteArr2HexStr(execCommand)
+        )
+        val res = command.send(this)
+
+        printLog(TAG, "<--- changePin end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        return if (res.isConnectFailure()) {
+            NfcConstant.INTERRUPT_STATUS
+        } else if (res.isSuccess()) {
+            printLog(TAG, "--- verify success")
+            NfcConstant.CHANGE_PIN_SUCCESS
+        } else if (res.getCode() == "9B01") {
+            // V1 Lite Pin error
+            printLog(TAG, "--- verify error")
+            retryNumCommandAndReset()
+        } else if (res.getCode() == "6983") {
+            // V2 Lite Locked
+            printLog(TAG, "--- verify Too many errors, Locked")
+            resetCard()
+        } else {
+            if (res.getCode().startsWith("63C")) {
+                return res.sw2.toInt() and 0x0F
+            }
+            retryNumCommandAndReset()
+        }
+    }
+
+    fun startVerifyPin(pin: String): Int {
+        printLog(TAG, "---> startVerifyPin begin")
+        val pinHex = HexUtils.stringToHexString(pin)
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.VERIFY_PIN, hasOpenSafeChannel, "06$pinHex"
+        )
+        val res = command.send(this)
+        printLog(TAG, "<--- startVerifyPin end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        return if (res.isConnectFailure()) {
+            NfcConstant.INTERRUPT_STATUS
+        } else if (res.isSuccess()) {
+            printLog(TAG, "--- verify success")
+            NfcConstant.VERIFY_SUCCESS
+        } else if (res.getCode() == "9B01") {
+            // V1 Lite Pin error
+            printLog(TAG, "--- verify error")
+            retryNumCommandAndReset()
+        } else if (res.getCode() == "6983") {
+            // V2 Lite Locked
+            printLog(TAG, "--- verify Too many errors, Locked")
+            resetCard()
+        } else {
+            if (res.getCode().startsWith("63C")) {
+                return res.sw2.toInt() and 0x0F
+            }
+            retryNumCommandAndReset()
+        }
+    }
+
+    fun backupData(mnemonic: String): Boolean {
+        printLog(TAG, "---> backupData begin")
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.BACKUP_DATA, hasOpenSafeChannel, mnemonic
+        )
+        val res = command.send(this)
+        printLog(TAG, "<--- backupData end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        if (!res.isSuccess()) {
+            return false
+        }
+
+        return true
+    }
+
+    fun exportData(): String? {
+        printLog(TAG, "---> exportData begin")
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.EXPORT_DATA, hasOpenSafeChannel
+        )
+        val res = command.send(this)
+        printLog(
+            TAG,
+            "<--- exportData end: ${res.getCode()} emptyData:${res.isEmptyData()} area:${mCommandArea}"
+        )
+
+        if (res.isEmptyData() || !res.isSuccess()) {
+            return null
+        }
+
+        return res.result
+    }
+
+    private fun retryNumCommandAndReset(): Int {
+        val leftRetryNum = getRetryCount()
+        return if (leftRetryNum == 0) {
+            resetCard()
+        } else {
+            leftRetryNum
+        }
+    }
+
+    fun resetCard(): Int {
+        printLog(TAG, "---> resetCard begin")
+        val command = mCommandGenerator.generalCommand(
+            mCardType, CommandType.RESET_CARD, hasOpenSafeChannel, "DFFE028205"
+        )
+        val res = command.send(this)
+
+        printLog(TAG, "<--- resetCard end: ${res.getCode()} ${res.data} area:${mCommandArea}")
+
+        return if (res.isConnectFailure()) {
+            NfcConstant.RESET_INTERRUPT_STATUS
+        } else {
+            NfcConstant.RESET_PIN_SUCCESS
+        }
+    }
+}

package/android/src/main/java/so/onekey/app/wallet/onekeyLite/nfc/GPCAPDUGenerator.kt

@@ -0,0 +1,56 @@
+package so.onekey.app.wallet.onekeyLite.nfc
+
+import com.google.gson.Gson
+import org.haobtc.onekey.card.gpchannel.GPChannelNatives
+import so.onekey.app.wallet.onekeyLite.entitys.APDUParam
+import so.onekey.app.wallet.utils.LogUtil.printLog
+
+object GPCAPDUGenerator {
+    private const val TAG = "GPCAPDUGenerator"
+
+    @JvmStatic
+    fun buildGPCAPDU(param: APDUParam, safeChannel: Boolean = false): String {
+        printLog(TAG, "  --->> BuildGPCAPDU begin")
+        return if (safeChannel) {
+            GPChannelNatives.nativeGPCBuildSafeAPDU(
+                param.cla,
+                param.ins,
+                param.p1,
+                param.p2,
+                param.data
+            )
+        } else {
+            GPChannelNatives.nativeGPCBuildAPDU(
+                param.cla,
+                param.ins,
+                param.p1,
+                param.p2,
+                param.data
+            )
+        }.also {
+            printLog(TAG, "  <<--- BuildGPCAPDU done: safeChannel:$safeChannel")
+        }
+    }
+
+    @JvmStatic
+    fun combCommand(command: ByteArray? = null, vararg params: ByteArray?): ByteArray {
+        var combParam = byteArrayOf()
+        params.forEach { param ->
+            param?.let {
+                combParam = combParam.plus(it.size.toByte())
+                combParam = combParam.plus(it)
+            }
+        }
+
+        var combCommand = byteArrayOf()
+        command?.let {
+            combCommand = combCommand.plus(it)
+            if (params.size != 1) {
+                // params 只有一个的时候就不再次拼接长度了
+                combCommand = combCommand.plus(combParam.size.toByte())
+            }
+        }
+        combCommand = combCommand.plus(combParam)
+        return combCommand
+    }
+}

package/android/src/main/java/so/onekey/app/wallet/utils/EventUtils.kt

@@ -0,0 +1,14 @@
+package so.onekey.app.wallet.utils
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+fun sendEvent(
+    reactContext: ReactContext,
+    eventName: String,
+    params: String? = null
+) {
+    reactContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(eventName, params)
+}