@onekeyfe/react-native-lite-card 1.0.0

package/ios/Classes/OKNFTLite/OKLiteV2.m

@@ -0,0 +1,132 @@
+//
+//  OKLiteV2.m
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import "OKLiteV2.h"
+#import "OKLiteCommandTool.h"
+#import "OKNFCUtility.h"
+
+@interface OKLiteV2 ()
+
+@end
+
+@implementation OKLiteV2
+
+- (instancetype)initWithDelegate:(id<OKNFCManagerDelegate>)delegate {
+    self = [super initWithDelegate:delegate];
+    if (!self) return self;
+    self.version = OKNFCLiteVersionV2;
+    return self;
+}
+
+#pragma mark - setMnemonic
+
+- (void)setMnemonic:(NSString *)mnemonic
+            withPin:(NSString *)pin
+           complete:(SetMnemonicCallback)callBack {
+
+    OKNFCLiteSetMncStatus status = OKNFCLiteSetMncStatusError;
+    BOOL selectNFCAppSuccess = [self selectNFCAppWith:OKLiteCommandImportMnemonic];
+    [self openSecureChannel];
+
+    if (self.status == OKNFCLiteStatusActivated) {
+        [self.delegate endNFCSessionWithError:YES];
+        callBack(self,status);
+        return;
+    }
+
+    if (self.status == OKNFCLiteStatusNewCard) {
+        [self setPin:pin];
+    }
+
+
+    if (selectNFCAppSuccess) {
+        OKNFCLitePINVerifyResult verifyResult = [self verifyPin:pin];
+        if (verifyResult == OKNFCLitePINVerifyResultPass) {
+            BOOL setMncSuccess = [self setMnc:mnemonic];
+            status = setMncSuccess ? OKNFCLiteSetMncStatusSuccess : OKNFCLiteSetMncStatusError;
+        } else if (verifyResult == OKNFCLitePINVerifyResultNotMatch) {
+            status = OKNFCLiteSetMncStatusPinNotMatch;
+            if (self.pinRTL <= 0) {
+                BOOL restSeccuss = [self resetSync];
+                status = restSeccuss ? OKNFCLiteSetMncStatusWiped : OKNFCLiteSetMncStatusError;
+            }
+        }
+    }
+    if (status == OKNFCLiteSetMncStatusSuccess) {
+        self.status = OKNFCLiteStatusActivated;
+    } else if (status == OKNFCLiteSetMncStatusWiped) {
+        self.status = OKNFCLiteStatusNewCard;
+    }
+    [self.delegate endNFCSessionWithError:status != OKNFCLiteSetMncStatusSuccess];
+    callBack(self,status);
+}
+
+
+- (void)setMnemonicOverWrite:(NSString *)mnemonic
+            withPin:(NSString *)pin
+           complete:(SetMnemonicCallback)callBack {
+    OKNFCLiteSetMncStatus status = OKNFCLiteSetMncStatusError;
+
+    BOOL selectNFCAppSuccess = [self selectNFCAppWith:OKLiteCommandImportMnemonic];
+    BOOL openSecureChannelSuccess = [self openSecureChannel];
+    if (selectNFCAppSuccess && openSecureChannelSuccess) {
+        if (self.status == OKNFCLiteStatusNewCard) {
+            [self setPin:pin];
+        } else {
+            OKNFCLitePINVerifyResult oldPinVerifyResult = [self verifyPin:pin];
+            if (oldPinVerifyResult == OKNFCLitePINVerifyResultPass) {
+                [self setPin:pin];
+            } else if (oldPinVerifyResult == OKNFCLitePINVerifyResultNotMatch) {
+                status = OKNFCLiteSetMncStatusPinNotMatch;
+                if (self.pinRTL <= 0) {
+                    BOOL restSeccuss = [self resetSync];
+                    status = restSeccuss ? OKNFCLiteSetMncStatusWiped : OKNFCLiteSetMncStatusError;
+                }
+            }
+        }
+
+        OKNFCLitePINVerifyResult verifyResult = [self verifyPin:pin];
+        if (verifyResult == OKNFCLitePINVerifyResultPass) {
+            BOOL setMncSuccess = [self setMnc:mnemonic];
+            status = setMncSuccess ? OKNFCLiteSetMncStatusSuccess : OKNFCLiteSetMncStatusError;
+        } else if (verifyResult == OKNFCLitePINVerifyResultNotMatch) {
+            status = OKNFCLiteSetMncStatusPinNotMatch;
+            if (self.pinRTL <= 0) {
+                BOOL restSeccuss = [self resetSync];
+                status = restSeccuss ? OKNFCLiteSetMncStatusWiped : OKNFCLiteSetMncStatusError;
+            }
+        }
+    }
+    if (status == OKNFCLiteSetMncStatusSuccess) {
+        self.status = OKNFCLiteStatusActivated;
+    } else if (status == OKNFCLiteSetMncStatusWiped) {
+        self.status = OKNFCLiteStatusNewCard;
+    }
+    [self.delegate endNFCSessionWithError:status != OKNFCLiteSetMncStatusSuccess];
+    callBack(self,status);
+}
+
+
+- (void)setMnemonic:(NSString *)mnemonic
+            withPin:(NSString *)pin
+          overwrite:(BOOL)overwrite
+           complete:(SetMnemonicCallback)callBack {
+
+    if (![self syncLiteInfo]) {
+        [self.delegate endNFCSessionWithError:YES];
+        callBack(self,OKNFCLiteSetMncStatusError);
+        return;
+    }
+
+    if (!overwrite) {
+        [self setMnemonic:mnemonic withPin:pin complete:callBack];
+    } else {
+        [self setMnemonicOverWrite:mnemonic withPin:pin complete:callBack];
+    }
+}
+
+@end

package/ios/Classes/OKNFTLite/OKNFCManager.h

@@ -0,0 +1,40 @@
+//
+//  OKNFCManager.h
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import <Foundation/Foundation.h>
+#import <CoreNFC/CoreNFC.h>
+#import "OKNFCLiteDefine.h"
+
+#define OKLITEFOLDERNAME    @"OK_DEVICES_INFO_LITE"
+
+
+@protocol OKNFCManagerDelegate <NSObject>
+
+- (id<NFCISO7816Tag>)getNFCsessionTag;
+
+- (OKNFCLiteSessionType)getSessionType;
+
+- (void)endNFCSessionWithError:(BOOL)isError;
+
+@end
+
+@interface OKNFCManager : NSObject
+
+@property (nonatomic, assign) OKNFCLiteSessionType sessionType;
+
+- (void)getLiteInfo:(GetLiteInfoCallback)callBack;
+
+- (void)reset:(ResetCallback)callBack;
+
+- (void)setMnemonic:(NSString *)mnemonic withPin:(NSString *)pin overwrite:(BOOL)overwrite complete:(SetMnemonicCallback)complete;
+
+- (void)getMnemonicWithPin:(NSString *)pin complete:(GetMnemonicCallback)complete;
+
+- (void)changePin:(NSString *)oldPin to:(NSString *)newPin complete:(ChangePinCallback)complete;
+
+
+@end

package/ios/Classes/OKNFTLite/OKNFCManager.m

@@ -0,0 +1,330 @@
+//
+//  OKNFCManager.m
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2023/6/27.
+//
+
+#import "OKNFCManager.h"
+#import "OKNFCBridge.h"
+#import "OKNFCUtility.h"
+#import <CoreNFC/CoreNFC.h>
+//#import "OKNFCHintViewController.h"
+//#import "OKMnemonic.h"
+#import "NSString+OKAdd.h"
+#import "OKTools.h"
+#import "OKLiteV1.h"
+#import "OKLiteV2.h"
+#import "OKLiteProtocol.h"
+#import "OKLiteCommandModal.h"
+
+
+
+#define kGetLiteInfoBlock    @"kGetLiteInfoBlock"
+#define kSetMnemonicBlock    @"kSetMnemonicBlock"
+#define kGetMnemonicBlock    @"kGetMnemonicBlock"
+#define kChangePinBlock      @"kChangePinBlock"
+#define kResetBlock          @"kResetBlock"
+
+
+
+
+@interface OKNFCManager() <NFCTagReaderSessionDelegate,OKNFCManagerDelegate>
+@property (nonatomic, strong) NFCTagReaderSession *session;
+@property (nonatomic, copy) NSString *pin;
+@property (nonatomic, copy) NSString *neoPin;
+@property (nonatomic, copy) NSString *exportMnemonic;
+@property (nonatomic, assign) BOOL certVerified;
+@property (nonatomic, assign) OKNFCLiteApp selectNFCApp;
+@property (nonatomic, strong) OKLiteV1 *lite;
+
+@property (nonatomic, strong) NSMutableDictionary *completionBlocks;
+
+@end
+
+@implementation OKNFCManager
+
+#pragma mark - OKNFCManagerDelegate
+
+- (id<NFCISO7816Tag>)getNFCsessionTag {
+    id<NFCISO7816Tag> tag = [self.session.connectedTag asNFCISO7816Tag];
+    return tag;
+}
+
+- (OKNFCLiteSessionType)getSessionType {
+    return self.sessionType;
+}
+
+
+- (void)endNFCSessionWithError:(BOOL)isError {
+    self.session.alertMessage = @"";
+    if (isError) {
+        [self.session invalidateSessionWithErrorMessage:OKTools.isChineseLan ? @"读取失败，请重试":@"Connect fail, please try again."];
+    } else {
+        [self.session invalidateSession];
+    }
+    self.session = nil;
+}
+
+
+-(NSMutableDictionary *)completionBlocks {
+    if (!_completionBlocks) {
+        _completionBlocks = [NSMutableDictionary dictionary];
+    }
+    return _completionBlocks;
+}
+
+- (void)beginNewNFCSession {
+    self.session = [[NFCTagReaderSession alloc] initWithPollingOption:NFCPollingISO14443 delegate:self queue:dispatch_get_global_queue(2, 0)];
+    [self.session beginSession];
+}
+
+#pragma mark - NFCTagReaderSessionDelegate
+
+- (void)tagReaderSession:(NFCTagReaderSession *)session didDetectTags:(NSArray<__kindof id<NFCTag>> *)tags {
+    NSLog(@"OKNFC tagReaderSession didDetectTags %@", tags);
+
+    id<NFCISO7816Tag> tag = [tags.firstObject asNFCISO7816Tag];
+    if (!tag) { return; }
+
+    [session connectToTag:tag completionHandler:^(NSError * _Nullable error) {
+        if (error) {
+            NSString *errMsg = [NSString stringWithFormat:@"OKNFC connectToTag %@", error];
+            NSLog(@"%@", errMsg);
+            //            [kTools debugTipMessage:errMsg];
+            [self endNFCSessionWithError:YES];
+            return;
+        }
+        [self nfcSessionComplete:session];
+    }];
+}
+
+- (void)tagReaderSession:(NFCTagReaderSession *)session didInvalidateWithError:(NSError *)error {
+    NSLog(@"OKNFC tagReaderSession didInvalidateWithError %@", error);
+    if (error.code == 200 || error.code == 6) {
+        switch (self.sessionType) {
+            case OKNFCLiteSessionTypeGetInfo:
+            case OKNFCLiteSessionTypeUpdateInfo:{
+                GetLiteInfoCallback callback = [_completionBlocks objectForKey:kGetLiteInfoBlock];
+                if(callback) {
+                    callback(nil,OKNFCLiteStatusError);
+                }
+            } break;
+            case OKNFCLiteSessionTypeReset: {
+                ResetCallback callback = [_completionBlocks objectForKey:kResetBlock];
+                if (callback) {
+                    callback(self.lite, NO,error);
+                }
+            } break;
+            case OKNFCLiteSessionTypeSetMnemonic:
+            case OKNFCLiteSessionTypeSetMnemonicForce: {
+                SetMnemonicCallback callback = [_completionBlocks objectForKey:kSetMnemonicBlock];
+                if (callback) {
+                    callback(self.lite,OKNFCLiteSetMncStatusCancel);
+                }
+            } break;
+            case OKNFCLiteSessionTypeGetMnemonic: {
+                GetMnemonicCallback callback = [_completionBlocks objectForKey:kGetMnemonicBlock];
+                if (callback) {
+                    callback(self.lite,nil,OKNFCLiteGetMncStatusCancel);
+                }
+            } break;
+            case OKNFCLiteSessionTypeChangePin: {
+                ChangePinCallback callback = [_completionBlocks objectForKey:kChangePinBlock];
+                if (callback) {
+                    callback(self.lite,OKNFCLiteChangePinStatusCancel);
+                }
+
+            } break;
+            default:
+                break;
+        }
+    }
+    [session invalidateSession];
+}
+
+- (void)tagReaderSessionDidBecomeActive:(NFCTagReaderSession *)session {
+    NSLog(@"OKNFC tagReaderSessionDidBecomeActive %@", session);
+}
+
+#pragma mark - Tasks
+
+- (void)nfcSessionComplete:(NFCTagReaderSession *)session {
+    if (![self checkLiteVersion]) {
+        [self endNFCSessionWithError:YES];
+    }
+    self.selectNFCApp = OKNFCLiteAppNONE;
+    switch (self.sessionType) {
+        case OKNFCLiteSessionTypeGetInfo:
+        case OKNFCLiteSessionTypeUpdateInfo:{
+            [self _getLiteInfo];
+        } break;
+        case OKNFCLiteSessionTypeReset: {
+            [self _reset];
+        } break;
+        case OKNFCLiteSessionTypeSetMnemonic: {
+            [self _setMnemonic:NO];
+        } break;
+        case OKNFCLiteSessionTypeSetMnemonicForce: {
+            [self _setMnemonic:YES];
+        } break;
+        case OKNFCLiteSessionTypeGetMnemonic: {
+            [self _getMnemonic];
+        } break;
+        case OKNFCLiteSessionTypeChangePin: {
+            [self _changePin];
+        } break;
+        default:
+            break;
+    }
+    self.sessionType = OKNFCLiteSessionTypeNone;
+}
+
+
+#pragma mark - getLiteInfo
+
+- (void)getLiteInfo:(GetLiteInfoCallback)callBack {
+    if (self.lite.SN.length > 0) {
+        self.sessionType = OKNFCLiteSessionTypeUpdateInfo;
+    } else {
+        self.sessionType = OKNFCLiteSessionTypeGetInfo;
+    }
+    [self.completionBlocks setObject:callBack forKey:kGetLiteInfoBlock];
+    [self beginNewNFCSession];
+}
+
+
+- (void)getLiteInfo {
+    if (self.lite.SN.length > 0) {
+        self.sessionType = OKNFCLiteSessionTypeUpdateInfo;
+    } else {
+        self.sessionType = OKNFCLiteSessionTypeGetInfo;
+    }
+    [self beginNewNFCSession];
+}
+
+- (void)_getLiteInfo {
+    GetLiteInfoCallback callback = [_completionBlocks objectForKey:kGetLiteInfoBlock];
+    [self.lite getLiteInfo:callback];
+}
+
+- (BOOL)syncLiteInfo {
+    return [self.lite syncLiteInfo];
+}
+
+#pragma mark - setMnemonic
+
+- (void)setMnemonic:(NSString *)mnemonic
+            withPin:(NSString *)pin
+          overwrite:(BOOL)overwrite
+           complete:(SetMnemonicCallback)complete {
+
+    if (pin.length != OKNFC_PIN_LENGTH) {
+        return;
+    }
+    self.pin = pin;
+    self.exportMnemonic = mnemonic;
+    if(overwrite) {
+        // 写入强制覆盖
+        self.sessionType = OKNFCLiteSessionTypeSetMnemonicForce;
+    } else {
+        self.sessionType = OKNFCLiteSessionTypeSetMnemonic;
+    }
+    [self.completionBlocks setObject:complete forKey:kSetMnemonicBlock];
+    [self beginNewNFCSession];
+
+}
+
+- (void)_setMnemonic:(BOOL)force {
+    SetMnemonicCallback callback = [_completionBlocks objectForKey:kSetMnemonicBlock];
+    [self.lite setMnemonic:self.exportMnemonic withPin:self.pin overwrite:force complete:callback];
+}
+
+#pragma mark - getMnemonic
+
+- (void)getMnemonicWithPin:(NSString *)pin complete:(GetMnemonicCallback)complete {
+    if (pin.length != OKNFC_PIN_LENGTH) {
+        return;
+    }
+    self.pin = pin;
+    self.sessionType = OKNFCLiteSessionTypeGetMnemonic;
+    [self.completionBlocks setObject:complete forKey:kGetMnemonicBlock];
+    [self beginNewNFCSession];
+}
+
+- (void)_getMnemonic {
+    GetMnemonicCallback callback = [_completionBlocks objectForKey:kGetMnemonicBlock];
+    [self.lite getMnemonicWithPin:self.pin complete:callback];
+}
+
+#pragma mark - changePin
+
+- (void)changePin:(NSString *)oldPin to:(NSString *)newPin complete:(ChangePinCallback)complete {
+    self.pin = oldPin;
+    self.neoPin = newPin;
+    self.sessionType = OKNFCLiteSessionTypeChangePin;
+    [self.completionBlocks setObject:complete forKey:kChangePinBlock];
+    [self beginNewNFCSession];
+}
+
+- (void)_changePin {
+    ChangePinCallback callback = [_completionBlocks objectForKey:kChangePinBlock];
+    [self.lite changePin:self.pin to:self.neoPin complete:callback];
+}
+
+#pragma mark - reset
+
+- (void)reset:(ResetCallback)callBack {
+    self.sessionType = OKNFCLiteSessionTypeReset;
+    [self.completionBlocks setObject:callBack forKey:kResetBlock];
+    [self beginNewNFCSession];
+}
+
+- (void)_reset {
+    ResetCallback callback = [_completionBlocks objectForKey:kResetBlock];
+    [self.lite reset:callback];
+}
+
+- (BOOL)_resetSync {
+    return [self.lite resetSync];
+}
+
+
+#pragma mark - CheckLiteVersion
+
+-(BOOL)checkLiteVersion {
+    id<NFCISO7816Tag> tag = [self.session.connectedTag asNFCISO7816Tag];
+    if (!tag) { return false; }
+
+    __block BOOL success = NO;
+    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+
+    OKLiteCommandModal *modalV1 = [[OKLiteCommandModal alloc] initWithCommand:OKLiteCommandSelectBackup version:OKNFCLiteVersionV1];
+    [tag sendCommandAPDU:[modalV1 buildAPDU] completionHandler:^(NSData *responseData, uint8_t sw1, uint8_t sw2, NSError *error) {
+        [OKNFCUtility logAPDU:@"检查是否LiteV1" response:responseData sw1:sw1 sw2:sw2 error:error];
+        success = sw1 == OKNFC_SW1_OK;
+
+        dispatch_semaphore_signal(sema);
+    }];
+    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+
+    if(success) {
+        self.lite = [[OKLiteV1 alloc] initWithDelegate:self];
+    } else {
+        OKLiteCommandModal *modalV2 = [[OKLiteCommandModal alloc] initWithCommand:OKLiteCommandSelectBackup version:OKNFCLiteVersionV2];
+        [tag sendCommandAPDU:[modalV2 buildAPDU] completionHandler:^(NSData *responseData, uint8_t sw1, uint8_t sw2, NSError *error) {
+            [OKNFCUtility logAPDU:@"检查是否LiteV2" response:responseData sw1:sw1 sw2:sw2 error:error];
+            success = sw1 == OKNFC_SW1_OK;
+            dispatch_semaphore_signal(sema);
+        }];
+        dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+        if (success) {
+            self.lite = [[OKLiteV2 alloc] initWithDelegate:self];
+        }
+    }
+
+    return success;
+}
+
+
+@end

package/ios/Classes/Utils/NFCConfig.h

@@ -0,0 +1,19 @@
+//
+//  NFCConfig.h
+//  OneKeyWallet
+//
+//  Created by linleiqin on 2022/2/22.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NFCConfig : NSObject
+
++ (NSDictionary *)env;
++ (NSString *)envFor: (NSString *)key;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Classes/Utils/NFCConfig.m

@@ -0,0 +1,18 @@
+#import "NFCConfig.h"
+#import "keys.h"
+
+@implementation NFCConfig
+
++ (NSDictionary *)env {
+    char *result = getInitParams();
+    NSData *data = [NSData dataWithBytesNoCopy:result length:strlen(result) freeWhenDone:YES];
+    NSDictionary *value = [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:NULL];
+    return value;
+}
+
++ (NSString *)envFor: (NSString *)key {
+    NSString *value = (NSString *)[self.env objectForKey:key];
+    return value;
+}
+
+@end

package/ios/Classes/Utils/NSData+OKNFCHexData.h

@@ -0,0 +1,17 @@
+//
+//  NSData+OKNFCHexData.h
+//
+//  Created by linleiqin on 2023/6/20.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NSData (OKNFCHexData)
+
+- (NSString *)toHexString;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Classes/Utils/NSData+OKNFCHexData.m

@@ -0,0 +1,24 @@
+//
+//  NSData+OKNFCHexData.m
+//
+//  Created by linleiqin on 2023/6/20.
+//
+
+#import "NSData+OKNFCHexData.h"
+
+@implementation NSData (OKNFCHexData)
+- (NSString *)toHexString {
+    const unsigned char *dataBuffer = (const unsigned char *)[self bytes];
+
+    if (!dataBuffer)
+        return [NSString string];
+
+    NSUInteger dataLength = [self length];
+    NSMutableString *hexString = [NSMutableString stringWithCapacity:(dataLength * 2)];
+
+    for (int i = 0; i < dataLength; ++i)
+        [hexString appendString:[NSString stringWithFormat:@"%02lx", (unsigned long)dataBuffer[i]]];
+    return [NSString stringWithString:hexString];
+}
+
+@end

package/ios/Classes/Utils/NSData+StringToData.h

@@ -0,0 +1,12 @@
+//
+//  NSData+StringToData.h
+//  OneKey
+//
+//  Created by xiaoliang on 2020/11/17.
+//  Copyright © 2020 OneKey. All rights reserved..
+//
+#import <Foundation/Foundation.h>
+
+@interface NSData (StringToData)
++ (NSString*)hexStringForData:(NSData*)data;
+@end

package/ios/Classes/Utils/NSData+StringToData.m

@@ -0,0 +1,25 @@
+//
+//  NSData+StringToData.m
+//  OneKey
+//
+//  Created by xiaoliang on 2020/11/17.
+//  Copyright © 2020 OneKey. All rights reserved..
+//
+
+#import "NSData+StringToData.h"
+
+@implementation NSData (StringToData)
++ (NSString*)hexStringForData:(NSData*)data
+{
+    if (data == nil) {
+        return nil;
+    }
+    NSMutableString* hexString = [NSMutableString string];
+    const unsigned char *p = [data bytes];
+    for (int i=0; i < [data length]; i++) {
+        [hexString appendFormat:@"%02x", *p++];
+    }
+    return hexString;
+}
+
+@end

package/ios/Classes/Utils/NSString+OKAdd.h

@@ -0,0 +1,14 @@
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NSString (OKAdd)
+
+- (NSString *)SHA256;
+- (BOOL)ok_match:(NSString *)regex;
++ (NSString *)generateRequestId;
+@end
+
+
+NS_ASSUME_NONNULL_END

package/ios/Classes/Utils/NSString+OKAdd.m

@@ -0,0 +1,40 @@
+//
+//  NSString+BXAdd.m
+//  Electron-Cash
+//
+//  Created by xiaoliang on 2020/9/28.
+//  Copyright © 2020 OneKey. All rights reserved..
+//
+
+#import "NSString+OKAdd.h"
+#import <CommonCrypto/CommonDigest.h>
+#import "NSData+StringToData.h"
+
+@implementation NSString (OKAdd)
+
+- (NSString *)SHA256
+{
+    const char *s = [self cStringUsingEncoding:NSASCIIStringEncoding];
+    NSData *keyData = [NSData dataWithBytes:s length:strlen(s)];
+
+    uint8_t digest[CC_SHA256_DIGEST_LENGTH] = {0};
+    CC_SHA256(keyData.bytes, (CC_LONG)keyData.length, digest);
+    NSData *out = [NSData dataWithBytes:digest length:CC_SHA256_DIGEST_LENGTH];
+    NSString *hash = [NSData hexStringForData:out];
+    return hash;
+}
+
+- (BOOL)ok_match:(NSString *)regex {
+    NSPredicate *pred = [NSPredicate predicateWithFormat:@"SELF MATCHES %@", regex];
+    BOOL isMatch = [pred evaluateWithObject:self];
+    return isMatch;
+}
+
++ (NSString *)generateRequestId {
+  long long milliseconds = (long long)([[NSDate date] timeIntervalSince1970] * 1000.0);
+  int r = arc4random_uniform(1000000);
+  return [NSString stringWithFormat:@"%lld:%d", milliseconds, r];
+}
+
+
+@end

package/ios/Classes/Utils/NSString+OKNFCHexStr.h

@@ -0,0 +1,18 @@
+//
+//  NSString+OKNFCHexStr.h
+//
+//  Created by linleiqin on 2023/6/20.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NSString (OKNFCHexStr)
+
+- (NSData *)dataFromHexString;
+- (NSString *)hexString;
+
+@end
+
+NS_ASSUME_NONNULL_END