@onekeyfe/react-native-lite-card 0.1.2

package/ios/Classes/OKLiteCommand/OKLiteCommandModal.h

@@ -0,0 +1,39 @@
+//
+//  OKLiteCommandModal.h
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import <Foundation/Foundation.h>
+#import <CoreNFC/CoreNFC.h>
+#import "OKNFCLiteDefine.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NFCISO7816APDU* _Nonnull (^BuildStrBlock)(void);
+
+
+@interface OKLiteCommandModal : NSObject
+
+@property (nonatomic,copy) NSString *desc;
+@property(nonatomic,assign)OKLiteCommand command;
+
+//@property (nonatomic,assign) OKNFCLiteApp app;
+@property (nonatomic,assign) BOOL parseResp;
+
+- (instancetype)initWithCommand:(OKLiteCommand)command version:(OKNFCLiteVersion)version;
+
+- (NFCISO7816APDU *)buildAPDU;
+
+- (NFCISO7816APDU *)setPIN:(NSString *)pin;
+
+- (NFCISO7816APDU *)changePIN:(NSString *)oldPin newPin:(NSString *)newPin;
+
+- (NFCISO7816APDU *)verifyPIN:(NSString *)pin;
+
+- (NFCISO7816APDU *)importMnemonic:(NSString *)mnemonic;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Classes/OKLiteCommand/OKLiteCommandModal.m

@@ -0,0 +1,143 @@
+//
+//  OKLiteCommandModal.m
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import "OKLiteCommandModal.h"
+#import "OKNFCBridge.h"
+#import "OKLiteCommandTool.h"
+#import "NFCConfig.h"
+
+@interface OKLiteCommandModal ()
+
+@property(nonatomic,assign)OKNFCLiteVersion version;
+
+@end
+
+@implementation OKLiteCommandModal
+
+- (instancetype)initWithCommand:(OKLiteCommand)command version:(OKNFCLiteVersion)version {
+    self = [super init];
+    if (!self) return self;
+    _command = command;
+    _version = version;
+//    _app = [OKLiteCommandTool getLiteAppWithCommand:command version:version];
+    _parseResp = NO;
+    [self initDesc];
+    return self;
+}
+
+- (void)initDesc {
+    switch (_command) {
+        case OKLiteCommandSelectSecure:
+            self.desc = @"设置:主安全域";
+            break;
+        case OKLiteCommandSelectBackup:
+            self.desc = @"设置:备份应用";
+            break;
+        case OKLiteCommandGetCardSN:
+            self.desc = @"获取SN";
+            break;
+        case OKLiteCommandGetCardCert:
+            self.desc = @"获取设备证书";
+            break;
+        case OKLiteCommandGetBackupStatus:
+            self.desc = @"是否存在备份";
+            break;
+        case OKLiteCommandGetPINStatus:
+            self.desc = @"是否设置 PIN";
+            break;
+        case OKLiteCommandExportMnemonic:
+            self.desc = @"导出数据";
+            break;
+        case OKLiteCommandImportMnemonic:
+            self.desc = @"备份数据";
+            break;
+        case OKLiteCommandPinRTL:
+            self.desc = @"获取密码的重试次数";
+            break;
+        case OKLiteCommandWipeCard:
+            self.desc = @"重置卡片";
+            break;
+        case OKLiteCommandOpenChannel_1:
+            self.desc = @"开启安全通道:verify_certificate";
+            break;
+        case OKLiteCommandOpenChannel_2:
+            self.desc = @"开启安全通道:verify_auth_data";
+            break;
+        case OKLiteCommandSetPIN:
+            self.desc = @"设置Pin";
+            break;
+        case OKLiteCommandChangePIN:
+            self.desc = @"修改 Pin";
+            break;
+        case OKLiteCommandVerifyPIN:
+            self.desc = @"验证 Pin";
+            break;
+    }
+}
+
+- (NFCISO7816APDU *)buildAPDU {
+    switch (_command) {
+        case OKLiteCommandSelectSecure:
+            return [OKNFCBridge buildAPDUWithStr:@"0x00a4040008A000000151000000" encrypt:NO];
+        case OKLiteCommandSelectBackup:
+            if (_version == OKNFCLiteVersionV2) {
+                return [OKNFCBridge buildAPDUWithStr:@"0x00a404000e6f6e656b65792e6261636b757001" encrypt:NO];
+            } else {
+                return [OKNFCBridge buildAPDUWithStr:@"0x00a4040008D156000132834001" encrypt:NO];
+            }
+        case OKLiteCommandGetCardSN:
+            return [OKNFCBridge buildAPDUWithStr:@"0x80CB800005DFFF028101" encrypt:NO];
+        case OKLiteCommandGetCardCert:
+            return [OKNFCBridge buildAPDUWithStr:@"0x80CABF2106A60483021518" encrypt:NO];
+        case OKLiteCommandGetBackupStatus:
+            return [OKNFCBridge buildAPDUWithStr:@"0x806a0000" encrypt:NO];
+        case OKLiteCommandGetPINStatus:
+            return [OKNFCBridge buildAPDUWithStr:@"0x80CB800005DFFF028105" encrypt:NO];
+        case OKLiteCommandExportMnemonic:
+            if (_version == OKNFCLiteVersionV2) {
+                return [OKNFCBridge buildAPDUWith_cla:0x80 ins:0x4b p1:0x00 p2:0x00 data:@"" encrypt:YES];
+            } else {
+                return [OKNFCBridge buildAPDUWithStr:@"0x804B0000" encrypt:NO];
+            }
+        case OKLiteCommandPinRTL:
+            return [OKNFCBridge buildAPDUWithStr:@"0x80cb800005dfff028102" encrypt:NO];
+        case OKLiteCommandWipeCard:
+            return [OKNFCBridge buildAPDUWith_cla:0x80 ins:0xcb p1:0x80 p2:0x00 data:@"dffe028205" encrypt:YES];
+        case OKLiteCommandOpenChannel_1:
+            return [OKNFCBridge buildAPDUWithStr:[@"0x802a1810XX" stringByAppendingString:[NFCConfig envFor:@"crt"]] encrypt:NO];
+        case OKLiteCommandOpenChannel_2:
+            return [OKNFCBridge buildAPDUWithStr:[@"0x80821815XX" stringByAppendingString:[OKNFCBridge mutualAuthData]] encrypt:NO];
+        default:
+            return nil;
+    }
+}
+
+- (NFCISO7816APDU *)setPIN:(NSString *)pin {
+    NSString *dataStr = [NSString stringWithFormat:@"DFFE0B8204080006%@", pin.hexString];
+    return [OKNFCBridge buildAPDUWith_cla:0x80 ins:0xcb p1:0x80 p2:0x00 data:dataStr encrypt:YES];
+}
+
+- (NFCISO7816APDU *)changePIN:(NSString *)oldPin newPin:(NSString *)newPin {
+    NSString *dataStr = [NSString stringWithFormat:@"DFFE0B82040e06%@06%@", oldPin.hexString, newPin.hexString];
+    return [OKNFCBridge buildAPDUWith_cla:0x80 ins:0xcb p1:0x80 p2:0x00 data:dataStr encrypt:YES];
+}
+
+- (NFCISO7816APDU *)verifyPIN:(NSString *)pin {
+    NSString *hexPin = [@"06" stringByAppendingString: [pin hexString]];
+    return [OKNFCBridge buildAPDUWith_cla:0x80 ins:0x20 p1:0x00 p2:0x00 data:hexPin encrypt:YES];
+}
+
+- (NFCISO7816APDU *)importMnemonic:(NSString *)mnemonic {
+    /// https://onekeyhq.atlassian.net/wiki/spaces/ONEKEY/pages/10551684/Lite
+    if (_version == OKNFCLiteVersionV2) {
+        return [OKNFCBridge buildAPDUWith_cla:0x80 ins:0x3B p1:0x00 p2:0x00 data:mnemonic encrypt:YES];
+    } else {
+        return [OKNFCBridge buildAPDUWithStr:[@"0x803B0000XX" stringByAppendingString:mnemonic] encrypt:NO];
+    }
+}
+
+@end

package/ios/Classes/OKLiteCommand/OKLiteCommandTool.h

@@ -0,0 +1,28 @@
+//
+//  OKLiteCommandTool.h
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import <Foundation/Foundation.h>
+#import "OKNFCLiteDefine.h"
+#import <CoreNFC/CoreNFC.h>
+#import "OKLiteCommandModal.h"
+#import "OKNFCManager.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OKLiteCommandTool : NSObject
+
+@property (nonatomic, weak) id<OKNFCManagerDelegate> delegate;
+
+- (void)sendCommandWithAPDU:(NFCISO7816APDU *)apdu
+                      modal:(OKLiteCommandModal *)modal
+          completionHandler:(void(^)(NSData *responseData, uint8_t sw1, uint8_t sw2, NSError * _Nullable error, NSString *parseRespon))completionHandler;
+
+//+ (OKNFCLiteApp)getLiteAppWithCommand:(OKLiteCommand)command version:(OKNFCLiteVersion)version;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Classes/OKLiteCommand/OKLiteCommandTool.m

@@ -0,0 +1,53 @@
+//
+//  OKLiteCommandTool.m
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import "OKLiteCommandTool.h"
+#import "OKNFCBridge.h"
+#import "OKNFCUtility.h"
+
+@implementation OKLiteCommandTool
+
+- (void)sendCommandWithAPDU:(NFCISO7816APDU *)apdu
+                  modal:(OKLiteCommandModal *)modal
+      completionHandler:(void(^)(NSData *responseData, uint8_t sw1, uint8_t sw2, NSError * _Nullable error, NSString *parseRespon))completionHandler {
+
+    id<NFCISO7816Tag> tag = [self.delegate getNFCsessionTag];
+    [tag sendCommandAPDU:apdu completionHandler:^(NSData *responseData, uint8_t sw1, uint8_t sw2, NSError *error) {
+        NSString *parseRespon = nil;
+        if(modal.parseResp && sw1 == OKNFC_SW1_OK) {
+            parseRespon = [OKNFCBridge parseSafeAPDUResponse:responseData sw1:sw1 sw2:sw2];
+        }
+
+        [OKNFCUtility logAPDU:modal.desc response:responseData sw1:sw1 sw2:sw2 error:error];
+        if (completionHandler) {
+            completionHandler(responseData,sw1,sw2,error,parseRespon);
+        }
+    }];
+}
+
+//
+//+ (OKNFCLiteApp)getLiteAppWithCommand:(OKLiteCommand)command version:(OKNFCLiteVersion)version {
+//    switch (command) {
+//        case OKLiteCommandGetCardSN:
+//        case OKLiteCommandGetPINStatus:
+//        case OKLiteCommandPinRTL:
+//        case OKLiteCommandSetPIN:
+//        case OKLiteCommandChangePIN:
+//        case OKLiteCommandWipeCard:
+//            return version == OKNFCLiteVersionV1 ? OKNFCLiteAppSecure : OKNFCLiteAppBackup;
+//        case OKLiteCommandGetBackupStatus:
+//        case OKLiteCommandVerifyPIN:
+//        case OKLiteCommandImportMnemonic:
+//        case OKLiteCommandExportMnemonic:
+//            return OKNFCLiteAppBackup;
+//        default:
+//            return OKNFCLiteAppNONE;
+//    }
+//}
+
+
+@end

package/ios/Classes/OKNFCBridge.h

@@ -0,0 +1,28 @@
+//
+//  Bridge.h
+//  NFCTagReader
+//
+//  Created by zj on 2021/3/16.
+//  Copyright © 2021 Apple. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <CoreNFC/CoreNFC.h>
+
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OKNFCBridge : NSObject
++ (NFCISO7816APDU *)buildAPDUWith_cla:(unsigned long)cla ins:(unsigned long)ins p1:(unsigned long)p1 p2:(unsigned long)p2 data:(NSString *)data encrypt:(BOOL)encrypt;
++ (NSString *)mutualAuthData;
++ (BOOL)openChannel:(NSData *)authRes;
++ (BOOL)JUB_GPC_Initialize:(NSData *)cert;
++ (NSString *)parseSafeAPDUResponse:(NSData *)data sw1:(uint8_t)sw1 sw2:(uint8_t)sw2;
++ (BOOL)parseAPDUResponse:(NSData *)data;
++ (BOOL)verifySN:(NSString *)SNData withCert:(NSData *)cert;
++ (NFCISO7816APDU *)buildAPDUWithStr:(NSString *)str encrypt:(BOOL)encrypt;
++ (void)closeSecureChannel;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Classes/OKNFCBridge.mm

@@ -0,0 +1,221 @@
+//
+//  Bridge.m
+//  NFCTagReader
+//
+//  Created by zj on 2021/3/16.
+//  Copyright © 2021 Apple. All rights reserved.
+//
+
+#if !TARGET_OS_SIMULATOR
+
+#import <GPChannelSDKCore/GPChannelSDKCore.h>
+#import "OKNFCLiteDefine.h"
+#import "NFCConfig.h"
+
+#endif
+
+
+
+#import "OKNFCBridge.h"
+
+@implementation OKNFCBridge
+
+#if !TARGET_OS_SIMULATOR
+
++ (NFCISO7816APDU *)buildAPDUWith_cla:(unsigned long)cla
+                                  ins:(unsigned long)ins
+                                   p1:(unsigned long)p1
+                                   p2:(unsigned long)p2
+                                 data:(NSString *)data
+                              encrypt:(BOOL)encrypt {
+    JUB_RV rv = JUBR_ERROR;
+    JUB_CHAR_CPTR c_data = [data UTF8String];
+
+    JUB_CHAR_PTR c_apdu = NULL;
+
+    if (encrypt) {
+        rv = JUB_GPC_BuildSafeAPDU(cla, ins, p1, p2, c_data, &c_apdu);
+    } else {
+        rv = JUB_GPC_BuildAPDU(cla, ins, p1, p2, c_data, &c_apdu);
+    }
+
+    if (JUBR_OK != rv) {
+        return nil;
+    }
+
+    NSString *hexStr = [NSString stringWithCString:c_apdu encoding:NSUTF8StringEncoding];
+    NSData *APDUData = [hexStr dataFromHexString];
+    NFCISO7816APDU *apdu = [[NFCISO7816APDU alloc] initWithData:APDUData];
+    return apdu;
+}
+
++ (NSString *)parseSafeAPDUResponse:(NSData *)data sw1:(uint8_t)sw1 sw2:(uint8_t)sw2 {
+
+    JUB_RV rv = JUBR_ERROR;
+
+    NSMutableData *mutableRaw = [[NSMutableData alloc] initWithData:data];
+    [mutableRaw appendBytes:&sw1 length:sizeof(sw1)];
+    [mutableRaw appendBytes:&sw2 length:sizeof(sw2)];
+
+    JUB_CHAR_CPTR c_data = [mutableRaw.toHexString UTF8String];
+
+    JUB_UINT16 wRet = 0;
+    JUB_CHAR_PTR pDecResp = nullptr;
+    rv = JUB_GPC_ParseSafeAPDUResponse(c_data ,&wRet, &pDecResp);
+    if (JUBR_OK != rv) {
+        return nil;
+    }
+
+    NSString *resp = [NSString stringWithCString:pDecResp encoding:NSUTF8StringEncoding];
+    JUB_FreeMemory(pDecResp);
+
+    return resp;
+}
+
++ (BOOL)parseAPDUResponse:(NSData *)data {
+
+    JUB_RV rv = JUBR_ERROR;
+    JUB_ULONG tag = 0;
+    JUB_CHAR_PTR value;
+    JUB_CHAR_CPTR c_data = [[data toHexString] UTF8String];
+
+    rv = JUB_GPC_TLVDecode(c_data, &tag, &value);
+    if (JUBR_OK != rv) {
+        return NO;
+    }
+
+    JUB_UINT16 wRet = 0;
+    JUB_CHAR_PTR pDecResp = nullptr;
+    rv = JUB_GPC_ParseAPDUResponse(c_data,&wRet, &pDecResp);
+    if (JUBR_OK != rv) {
+        return NO;
+    }
+
+    JUB_FreeMemory(pDecResp);
+
+    return YES;
+}
+
++ (NFCISO7816APDU *)buildAPDUWithStr:(NSString *)str encrypt:(BOOL)encrypt {
+    if (![str hasPrefix:@"0x"]) {
+        NSAssert(0, @"must starts with 0x");
+        return nil;
+    }
+
+    // drop str[10:12], since coreNFC will cal it for us.
+    NSString *meta = [str substringWithRange:NSMakeRange(0, 10)];
+    NSString *data = @"";
+    if (str.length > 12) {
+        data = [str substringFromIndex:12];
+    }
+
+    unsigned long long outVal;
+    NSScanner* scanner = [NSScanner scannerWithString:meta];
+    [scanner scanHexLongLong:&outVal];
+
+    unsigned long cla = outVal >> 24 & 0xff;
+    unsigned long ins = outVal >> 16 & 0xff;
+    unsigned long p1 =  outVal >> 8  & 0xff;
+    unsigned long p2 =  outVal & 0xff;
+
+    return [OKNFCBridge buildAPDUWith_cla:cla ins:ins p1:p1 p2:p2 data:data encrypt:encrypt];
+}
+
+
++ (NSString *)mutualAuthData {
+    JUB_CHAR_PTR mutualAuthData;
+    JUB_RV rv = JUB_GPC_BuildMutualAuthData(&mutualAuthData);
+
+    if (JUBR_OK != rv) {
+        return nil;
+    }
+
+    return [NSString stringWithFormat:@"%s", mutualAuthData];
+}
+
++ (BOOL)openChannel:(NSData *)authRes {
+    JUB_CHAR_CPTR authResp = [[authRes toHexString] UTF8String];
+    JUB_RV rv;
+
+    rv = JUB_GPC_OpenSecureChannel(authResp);
+    if (JUBR_OK != rv) {
+        NSLog(@"error: JUB_GPC_OpenSecureChannel");
+        return NO;
+    }
+    NSLog(@"OKNFC: openChannel success.");
+    return YES;
+}
+
++ (BOOL)JUB_GPC_Initialize:(NSData *)cert {
+    JUB_RV rv = JUBR_ERROR;
+    JUB_ULONG tag = 0;
+    JUB_CHAR_PTR value;
+    JUB_CHAR_CPTR c_data = [[cert toHexString] UTF8String];
+
+    rv = JUB_GPC_TLVDecode(c_data, &tag, &value);
+    if (JUBR_OK != rv) {
+        return NO;
+    }
+
+    JUB_CHAR_PTR sn = nullptr;
+    JUB_CHAR_PTR subjectID = nullptr;
+    rv = JUB_GPC_ParseCertificate(value, &sn, &subjectID);
+    if (JUBR_OK != rv) {
+        return NO;
+    }
+
+    NSLog(@"OKNFC: subjectID: %s",subjectID);
+    GPC_SCP11_SHAREDINFO shareInfo;
+    shareInfo.scpID = (char *)"1107";
+    shareInfo.keyUsage = (char *)"3C";
+    shareInfo.keyType = (char *)"88";
+    shareInfo.keyLength = (char *)"10";
+    shareInfo.hostID = (char *)"8080808080808080";
+    shareInfo.cardGroupID = subjectID;
+
+    // initParams.json -> sk
+    char *sk = (char *)[[NFCConfig envFor:@"sk"] UTF8String];
+
+    rv = JUB_GPC_Initialize(shareInfo, [NFCConfig envFor:@"crt"].UTF8String, sk);
+
+    if (JUBR_OK != rv) {
+        return NO;
+    }
+
+    NSLog(@"OKNFC: JUB_GPC_Initialize OK.");
+    return YES;
+}
+
++ (void)closeSecureChannel {
+    JUB_GPC_Finalize();
+}
+
++ (BOOL)verifySN:(NSString *)cardSN withCert:(NSData *)cert {
+    JUB_RV rv = JUBR_ERROR;
+    JUB_ULONG tag = 0;
+    JUB_CHAR_PTR value;
+    JUB_CHAR_CPTR c_data = [[cert toHexString] UTF8String];
+
+    rv = JUB_GPC_TLVDecode(c_data, &tag, &value);
+    if (JUBR_OK != rv) {
+        return NO;
+    }
+
+    JUB_CHAR_PTR sn = nullptr;
+    JUB_CHAR_PTR subjectID = nullptr;
+    rv = JUB_GPC_ParseCertificate(value, &sn, &subjectID);
+    if (JUBR_OK != rv) {
+        return NO;
+    }
+
+    NSString *certSN = [NSString stringWithCString:sn encoding:NSUTF8StringEncoding];
+
+    BOOL identical = [certSN isEqualToString:cardSN];
+
+    NSLog(@"OKNFC: certSN: %@; cardSN: %@; identical: %@",certSN, cardSN, identical ? @"YES✅" : @"NO❌");
+    return identical;
+}
+
+#endif
+
+@end

package/ios/Classes/OKNFCLiteDefine.h

@@ -0,0 +1,108 @@
+//
+//  OKNFCLiteDefine.m
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import <Foundation/Foundation.h>
+#import "NSString+OKNFCHexStr.h"
+#import "NSData+OKNFCHexData.h"
+
+typedef NS_ENUM(NSInteger, OKLiteCommand) {
+    OKLiteCommandSelectSecure = 0,
+    OKLiteCommandSelectBackup,
+    OKLiteCommandGetCardSN,
+    OKLiteCommandGetCardCert,
+    OKLiteCommandGetBackupStatus,
+    OKLiteCommandGetPINStatus,
+    OKLiteCommandSetPIN,
+    OKLiteCommandChangePIN,
+    OKLiteCommandVerifyPIN,
+    OKLiteCommandImportMnemonic,
+    OKLiteCommandExportMnemonic,
+    OKLiteCommandWipeCard,
+    OKLiteCommandPinRTL,
+    OKLiteCommandOpenChannel_1,
+    OKLiteCommandOpenChannel_2,
+};
+
+typedef NS_ENUM(NSInteger, OKNFCLiteSessionType) {
+    OKNFCLiteSessionTypeNone = 0,
+    OKNFCLiteSessionTypeGetInfo,
+    OKNFCLiteSessionTypeSetMnemonic,
+    OKNFCLiteSessionTypeSetMnemonicForce,
+    OKNFCLiteSessionTypeGetMnemonic,
+    OKNFCLiteSessionTypeReset,
+    OKNFCLiteSessionTypeUpdateInfo,
+    OKNFCLiteSessionTypeChangePin,
+};
+
+typedef NS_ENUM(NSInteger, OKNFCLiteStatus) {
+    OKNFCLiteStatusError = 1,
+    OKNFCLiteStatusNewCard = 2,
+    OKNFCLiteStatusActivated = 3,
+    OKNFCLiteStatusSNNotMatch,
+};
+
+typedef NS_ENUM(NSInteger, OKNFCLiteSetMncStatus) {
+    OKNFCLiteSetMncStatusError = -1,
+    OKNFCLiteSetMncStatusSuccess = 0,
+    OKNFCLiteSetMncStatusSNNotMatch,
+    OKNFCLiteSetMncStatusPinNotMatch,
+    OKNFCLiteSetMncStatusWiped,
+    OKNFCLiteSetMncStatusCancel
+};
+
+typedef NS_ENUM(NSInteger, OKNFCLiteGetMncStatus) {
+    OKNFCLiteGetMncStatusError = -1,
+    OKNFCLiteGetMncStatusSuccess = 0,
+    OKNFCLiteGetMncStatusSNNotMatch,
+    OKNFCLiteGetMncStatusPinNotMatch,
+    OKNFCLiteGetMncStatusWiped,
+    OKNFCLiteGetMncStatusCancel,
+};
+
+typedef NS_ENUM(NSInteger, OKNFCLiteChangePinStatus) {
+    OKNFCLiteChangePinStatusError = -1,
+    OKNFCLiteChangePinStatusSuccess = 0,
+    OKNFCLiteChangePinStatusSNNotMatch,
+    OKNFCLiteChangePinStatusPinNotMatch,
+    OKNFCLiteChangePinStatusWiped,
+    OKNFCLiteChangePinStatusCancel,
+};
+
+@class OKLiteV1;
+typedef void (^GetLiteInfoCallback)(OKLiteV1 *lite, OKNFCLiteStatus status);
+typedef void (^ResetCallback)(OKLiteV1 *lite, BOOL isSuccess,NSError *error);
+typedef void (^SetMnemonicCallback)(OKLiteV1 *lite, OKNFCLiteSetMncStatus status);
+typedef void (^GetMnemonicCallback)(OKLiteV1 *lite, NSString*mnemonic, OKNFCLiteGetMncStatus status);
+typedef void (^ChangePinCallback)(OKLiteV1 *lite, OKNFCLiteChangePinStatus status);
+
+static const NSInteger OKNFC_PIN_LENGTH = 6;
+static const NSInteger OKNFC_PIN_UNSET = -1;
+static const NSInteger OKNFC_PIN_ERROR = -2;
+
+typedef NS_ENUM(NSInteger, OKNFCLiteApp) {
+    OKNFCLiteAppNONE = -1,
+    OKNFCLiteAppSecure = 0, // 主安全域
+    OKNFCLiteAppBackup = 1, // 备份
+};
+
+typedef NS_ENUM(NSInteger, OKNFCLitePINVerifyResult) {
+    OKNFCLitePINVerifyResultError = -1,
+    OKNFCLitePINVerifyResultPass = 0,
+    OKNFCLitePINVerifyResultNotMatch,
+};
+
+typedef NS_ENUM(NSInteger, OKNFCLiteChangePinResult) {
+    OKNFCLiteChangePinResultError = -1,
+    OKNFCLiteChangePinResultPass = 0,
+    OKNFCLiteChangePinResultWiped,
+};
+
+typedef NS_ENUM(NSInteger, OKNFCLiteVersion) {
+    OKNFCLiteVersionV1 = 0,
+    OKNFCLiteVersionV2 = 1,
+};
+

package/ios/Classes/OKNFTLite/OKLiteProtocol.h

@@ -0,0 +1,37 @@
+//
+//  OKLiteProtocol.h
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import <Foundation/Foundation.h>
+#import "OKNFCLiteDefine.h"
+#import <CoreNFC/CoreNFC.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol OKLiteProtocol <NSObject>
+
+- (void)getLiteInfo:(GetLiteInfoCallback)callBack;
+
+- (BOOL)syncLiteInfo;
+
+- (void)setMnemonic:(NSString *)mnemonic
+            withPin:(NSString *)pin
+          overwrite:(BOOL)overwrite
+           complete:(SetMnemonicCallback)complete;
+
+- (void)reset:(ResetCallback)callBack;
+
+- (BOOL)resetSync;
+
+- (void)getMnemonicWithPin:(NSString *)pin complete:(GetMnemonicCallback)complete;
+
+- (void)changePin:(NSString *)oldPin to:(NSString *)newPin complete:(ChangePinCallback)complete;
+
+- (OKNFCLitePINVerifyResult)verifyPin:(NSString *)pin;
+
+@end
+
+NS_ASSUME_NONNULL_END