bump version

use a default pairing password

android/src/main/AndroidManifest.xml

@@ -1,6 +1,6 @@
 
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.reactlibrary">
+          package="im.status.ethereum.keycard">
 
 </manifest>
-  
+  

android/src/main/java/im/status/ethereum/keycard/RNStatusKeycardModule.java

@@ -14,6 +14,7 @@ import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.ReadableMap;
 
 import java.io.IOException;
 import java.security.NoSuchAlgorithmException;
@@ -119,11 +120,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void generateMnemonic(final String pairing, final String words, final Promise promise) {
+    public void generateMnemonic(final String words, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    promise.resolve(smartCard.generateMnemonic(pairing, words));
+                    promise.resolve(smartCard.generateMnemonic(words));
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
                     promise.reject(e);
@@ -133,11 +134,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void generateAndLoadKey(final String mnemonic, final String pairing, final String pin, final Promise promise) {
+    public void generateAndLoadKey(final String mnemonic, final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    promise.resolve(smartCard.generateAndLoadKey(mnemonic, pairing, pin));
+                    promise.resolve(smartCard.generateAndLoadKey(mnemonic, pin));
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
                     promise.reject(e);
@@ -147,11 +148,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void saveMnemonic(final String mnemonic, final String pairing, final String pin, final Promise promise) {
+    public void saveMnemonic(final String mnemonic, final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    smartCard.saveMnemonic(mnemonic, pairing, pin);
+                    smartCard.saveMnemonic(mnemonic, pin);
                     promise.resolve(true);
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
@@ -162,11 +163,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void getApplicationInfo(final String pairingBase64, final Promise promise) {
+    public void getApplicationInfo(final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    promise.resolve(smartCard.getApplicationInfo(pairingBase64));
+                    promise.resolve(smartCard.getApplicationInfo());
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
                     promise.reject(e);
@@ -176,11 +177,25 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void deriveKey(final String path, final String pairing, final String pin, final Promise promise) {
+    public void factoryReset(final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    smartCard.deriveKey(path, pairing, pin);
+                    promise.resolve(smartCard.factoryReset());
+                } catch (IOException | APDUException e) {
+                    Log.d(TAG, e.getMessage());
+                    promise.reject(e);
+                }
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void deriveKey(final String path, final String pin, final Promise promise) {
+        new Thread(new Runnable() {
+            public void run() {
+                try {
+                    smartCard.deriveKey(path, pin);
                     promise.resolve(path);
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
@@ -191,11 +206,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void exportKey(final String pairing, final String pin, final Promise promise) {
+    public void exportKey(final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    promise.resolve(smartCard.exportKey(pairing, pin));
+                    promise.resolve(smartCard.exportKey(pin));
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
                     promise.reject(e);
@@ -205,26 +220,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void exportKeyWithPath(final String pairing, final String pin, final String path, final Promise promise) {
+    public void exportKeyWithPath(final String pin, final String path, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    promise.resolve(smartCard.exportKeyWithPath(pairing, pin, path));
-                } catch (IOException | APDUException e) {
-                    Log.d(TAG, e.getMessage());
-                    promise.reject(e);
-                }
-            }
-        }).start();
-    }
-
-
-    @ReactMethod
-    public void getKeys(final String pairing, final String pin, final Promise promise) {
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    promise.resolve(smartCard.getKeys(pairing, pin));
+                    promise.resolve(smartCard.exportKeyWithPath(pin, path));
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
                     promise.reject(e);
@@ -234,11 +234,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void sign(final String pairing, final String pin, final String hash, final Promise promise) {
+    public void getKeys(final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    promise.resolve(smartCard.sign(pairing, pin, hash));
+                    promise.resolve(smartCard.getKeys(pin));
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
                     promise.reject(e);
@@ -248,11 +248,39 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void signWithPath(final String pairing, final String pin, final String path, final String hash, final Promise promise) {
+    public void importKeys(final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    promise.resolve(smartCard.signWithPath(pairing, pin, path, hash));
+                    promise.resolve(smartCard.importKeys(pin));
+                } catch (IOException | APDUException e) {
+                    Log.d(TAG, e.getMessage());
+                    promise.reject(e);
+                }
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void sign(final String pin, final String hash, final Promise promise) {
+        new Thread(new Runnable() {
+            public void run() {
+                try {
+                    promise.resolve(smartCard.sign(pin, hash));
+                } catch (IOException | APDUException e) {
+                    Log.d(TAG, e.getMessage());
+                    promise.reject(e);
+                }
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void signWithPath(final String pin, final String path, final String hash, final Promise promise) {
+        new Thread(new Runnable() {
+            public void run() {
+                try {
+                    promise.resolve(smartCard.signWithPath(pin, path, hash));
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
                     promise.reject(e);
@@ -314,11 +342,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void verifyPin(final String pairing, final String pin, final Promise promise) {
+    public void verifyPin(final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    promise.resolve(smartCard.verifyPin(pairing, pin));
+                    promise.resolve(smartCard.verifyPin(pin));
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
                     promise.reject(e);
@@ -328,11 +356,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void changePin(final String pairing, final String currentPin, final String newPin, final Promise promise) {
+    public void changePairingPassword(final String pin, final String pairingPassword, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    smartCard.changePin(pairing, currentPin, newPin);
+                    smartCard.changePairingPassword(pin, pairingPassword);
                     promise.resolve(true);
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
@@ -343,11 +371,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void unblockPin(final String pairing, final String puk, final String newPin, final Promise promise) {
+    public void changePUK(final String pin, final String puk, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    smartCard.unblockPin(pairing, puk, newPin);
+                    smartCard.changePUK(pin, puk);
                     promise.resolve(true);
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
@@ -358,11 +386,41 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void unpair(final String pairing, final String pin, final Promise promise) {
+    public void changePin(final String currentPin, final String newPin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    smartCard.unpair(pairing, pin);
+                    smartCard.changePin(currentPin, newPin);
+                    promise.resolve(true);
+                } catch (IOException | APDUException e) {
+                    Log.d(TAG, e.getMessage());
+                    promise.reject(e);
+                }
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void unblockPin(final String puk, final String newPin, final Promise promise) {
+        new Thread(new Runnable() {
+            public void run() {
+                try {
+                    smartCard.unblockPin(puk, newPin);
+                    promise.resolve(true);
+                } catch (IOException | APDUException e) {
+                    Log.d(TAG, e.getMessage());
+                    promise.reject(e);
+                }
+            }
+        }).start();
+    }
+
+    @ReactMethod
+    public void unpair(final String pin, final Promise promise) {
+        new Thread(new Runnable() {
+            public void run() {
+                try {
+                    smartCard.unpair(pin);
                     promise.resolve(true);
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
@@ -388,11 +446,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void removeKey(final String pairing, final String pin, final Promise promise) {
+    public void removeKey(final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    smartCard.removeKey(pairing, pin);
+                    smartCard.removeKey(pin);
                     promise.resolve(true);
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
@@ -403,11 +461,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void removeKeyWithUnpair(final String pairing, final String pin, final Promise promise) {
+    public void removeKeyWithUnpair(final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    smartCard.removeKeyWithUnpair(pairing, pin);
+                    smartCard.removeKeyWithUnpair(pin);
                     promise.resolve(true);
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
@@ -418,11 +476,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     }
 
     @ReactMethod
-    public void unpairAndDelete(final String pairing, final String pin, final Promise promise) {
+    public void unpairAndDelete(final String pin, final Promise promise) {
         new Thread(new Runnable() {
             public void run() {
                 try {
-                    smartCard.unpairAndDelete(pairing, pin);
+                    smartCard.unpairAndDelete(pin);
                     promise.resolve(true);
                 } catch (IOException | APDUException e) {
                     Log.d(TAG, e.getMessage());
@@ -446,5 +504,11 @@ public class RNStatusKeycardModule extends ReactContextBaseJavaModule implements
     @ReactMethod
     public void setNFCMessage(String message, final Promise promise) {
         promise.resolve(true);
-    }    
+    }
+
+    @ReactMethod
+    public void setPairings(ReadableMap pairings, final Promise promise) {
+        smartCard.setPairings(pairings);
+        promise.resolve(true);
+    }
 }

android/src/main/java/im/status/ethereum/keycard/SmartCard.java

@@ -8,7 +8,6 @@ import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.nfc.NfcAdapter;
-import android.support.annotation.Nullable;
 import android.util.EventLog;
 import android.util.Log;
 
@@ -21,10 +20,14 @@ import java.security.NoSuchAlgorithmException;
 import java.security.spec.InvalidKeySpecException;
 import java.util.ArrayList;
 import java.util.Scanner;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
 
 import im.status.keycard.applet.RecoverableSignature;
 import im.status.keycard.globalplatform.GlobalPlatformCommandSet;
 import im.status.keycard.io.APDUException;
+import im.status.keycard.io.APDUResponse;
 import im.status.keycard.io.CardChannel;
 import im.status.keycard.io.CardListener;
 import im.status.keycard.android.NFCCardManager;
@@ -46,6 +49,7 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
     private EventEmitter eventEmitter;
     private static final String TAG = "SmartCard";
     private Boolean started = false;
+    private HashMap<String, String> pairings;
 
     private static final String MASTER_PATH = "m";
     private static final String ROOT_PATH = "m/44'/60'/0'/0";
@@ -58,6 +62,7 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         this.cardManager = new NFCCardManager();
         this.cardManager.setCardListener(this);
         this.eventEmitter = new EventEmitter(reactContext);
+        this.pairings = new HashMap<>();
     }
 
     public String getName() {
@@ -160,7 +165,8 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
 
         // First thing to do is selecting the applet on the card.
         ApplicationInfo info = new ApplicationInfo(cmdSet.select().checkOK().getData());
-        Log.i(TAG, "Instance UID: " + Hex.toHexString(info.getInstanceUID()));
+        String instanceUID = Hex.toHexString(info.getInstanceUID());
+        Log.i(TAG, "Instance UID: " + instanceUID);
         Log.i(TAG, "Key UID: " + Hex.toHexString(info.getKeyUID()));
         Log.i(TAG, "Secure channel public key: " + Hex.toHexString(info.getSecureChannelPubKey()));
         Log.i(TAG, "Application version: " + info.getAppVersionString());
@@ -169,19 +175,12 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         cmdSet.autoPair(pairingPassword);
 
         Pairing pairing = cmdSet.getPairing();
-
+        pairings.put(instanceUID, pairing.toBase64());
         return pairing.toBase64();
     }
 
-    public String generateMnemonic(String pairingBase64, String words) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
+    public String generateMnemonic(String words) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = securedCommandSet();
 
         Mnemonic mnemonic = new Mnemonic(cmdSet.generateMnemonic(KeycardCommandSet.GENERATE_MNEMONIC_12_WORDS).checkOK().getData());
 
@@ -198,18 +197,8 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         return mnemonic.toMnemonicPhrase();
     }
 
-    public void saveMnemonic(String mnemonic, String pairingBase64, String pin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+    public void saveMnemonic(String mnemonic, String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         byte[] seed = Mnemonic.toBinarySeed(mnemonic, "");
         cmdSet.loadKey(seed);
@@ -217,7 +206,23 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         log("seed loaded to card");
     }
 
-    public WritableMap getApplicationInfo(final String pairingBase64) throws IOException, APDUException {
+    public boolean tryDefaultPairing(KeycardCommandSet cmdSet, String instanceUID, WritableMap cardInfo) throws IOException {
+        try {
+            cmdSet.autoPair("KeycardDefaultPairing");
+
+            Pairing pairing = cmdSet.getPairing();
+            pairings.put(instanceUID, pairing.toBase64());
+            cardInfo.putString("new-pairing", pairing.toBase64());
+
+            openSecureChannel(cmdSet);
+            return true;
+        } catch(APDUException e) {
+            Log.i(TAG, "autoOpenSecureChannel failed: " + e.getMessage());
+            return false;
+        }
+    }
+
+    public WritableMap getApplicationInfo() throws IOException, APDUException {
         KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
         ApplicationInfo info = new ApplicationInfo(cmdSet.select().checkOK().getData());
 
@@ -227,7 +232,9 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         cardInfo.putBoolean("initialized?", info.isInitializedCard());
 
         if (info.isInitializedCard()) {
-            Log.i(TAG, "Instance UID: " + Hex.toHexString(info.getInstanceUID()));
+            String instanceUID = Hex.toHexString(info.getInstanceUID());
+
+            Log.i(TAG, "Instance UID: " + instanceUID);
             Log.i(TAG, "Key UID: " + Hex.toHexString(info.getKeyUID()));
             Log.i(TAG, "Secure channel public key: " + Hex.toHexString(info.getSecureChannelPubKey()));
             Log.i(TAG, "Application version: " + info.getAppVersionString());
@@ -235,27 +242,25 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
 
             Boolean isPaired = false;
 
-            if (pairingBase64.length() > 0) {
-                Pairing pairing = new Pairing(pairingBase64);
-                cmdSet.setPairing(pairing);
-
+            if (!pairings.containsKey(instanceUID)) {
+                isPaired = tryDefaultPairing(cmdSet, instanceUID, cardInfo);
+            } else {
                 try {
-                    cmdSet.autoOpenSecureChannel();
-                    Log.i(TAG, "secure channel opened");
+                    openSecureChannel(cmdSet);
                     isPaired = true;
                 } catch(APDUException e) {
-                    Log.i(TAG, "autoOpenSecureChannel failed: " + e.getMessage());
+                    isPaired = tryDefaultPairing(cmdSet, instanceUID, cardInfo);
                 }
+            }
 
-                if (isPaired) {
-                    ApplicationStatus status = new ApplicationStatus(cmdSet.getStatus(KeycardCommandSet.GET_STATUS_P1_APPLICATION).checkOK().getData());
+            if (isPaired) {
+                ApplicationStatus status = new ApplicationStatus(cmdSet.getStatus(KeycardCommandSet.GET_STATUS_P1_APPLICATION).checkOK().getData());
 
-                    Log.i(TAG, "PIN retry counter: " + status.getPINRetryCount());
-                    Log.i(TAG, "PUK retry counter: " + status.getPUKRetryCount());
+                Log.i(TAG, "PIN retry counter: " + status.getPINRetryCount());
+                Log.i(TAG, "PUK retry counter: " + status.getPUKRetryCount());
 
-                    cardInfo.putInt("pin-retry-counter", status.getPINRetryCount());
-                    cardInfo.putInt("puk-retry-counter", status.getPUKRetryCount());
-                }
+                cardInfo.putInt("pin-retry-counter", status.getPINRetryCount());
+                cardInfo.putInt("puk-retry-counter", status.getPUKRetryCount());
             }
 
             cardInfo.putBoolean("has-master-key?", info.hasMasterKey());
@@ -270,18 +275,31 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         return cardInfo;
     }
 
-    public void deriveKey(final String path, final String pairingBase64, final String pin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
+    public WritableMap factoryReset() throws IOException, APDUException {
+        GlobalPlatformCommandSet cmdSet = new GlobalPlatformCommandSet(this.cardChannel);
         cmdSet.select().checkOK();
+        Log.i(TAG, "ISD selected");
 
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
+        cmdSet.openSecureChannel();
+        Log.i(TAG, "SecureChannel opened");
 
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
+        cmdSet.deleteKeycardInstance().checkSW(APDUResponse.SW_OK, APDUResponse.SW_REFERENCED_DATA_NOT_FOUND);
+        Log.i(TAG, "Keycard applet instance deleted");
 
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+        cmdSet.installKeycardApplet().checkOK();
+        Log.i(TAG, "Keycard applet instance re-installed");
+
+        ApplicationInfo info = new ApplicationInfo(new KeycardCommandSet(this.cardChannel).select().checkOK().getData());
+        Log.i(TAG, "Selecting the newly installed Keycard applet succeeded");
+
+        WritableMap cardInfo = Arguments.createMap();
+        cardInfo.putBoolean("initialized?", info.isInitializedCard());
+
+        return cardInfo;
+    }
+
+    public void deriveKey(final String path, final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         KeyPath currentPath = new KeyPath(cmdSet.getStatus(KeycardCommandSet.GET_STATUS_P1_KEY_PATH).checkOK().getData());
         Log.i(TAG, "Current key path: " + currentPath);
@@ -292,54 +310,46 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         }
     }
 
-    public String exportKey(final String pairingBase64, final String pin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+    public String exportKey(final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         byte[] key = cmdSet.exportCurrentKey(true).checkOK().getData();
 
         return Hex.toHexString(key);
     }
 
-    public String exportKeyWithPath(final String pairingBase64, final String pin, final String path) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+    public String exportKeyWithPath(final String pin, final String path) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         byte[] key = BIP32KeyPair.fromTLV(cmdSet.exportKey(path, false, true).checkOK().getData()).getPublicKey();
 
         return Hex.toHexString(key);
     }
 
-    public WritableMap getKeys(final String pairingBase64, final String pin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
+    public WritableMap getKeys(final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
+        byte[] tlvWhisper = cmdSet.exportKey(WHISPER_PATH, false, false).checkOK().getData();
+        BIP32KeyPair whisperKeyPair = BIP32KeyPair.fromTLV(tlvWhisper);
 
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
+        byte[] tlvEncryption = cmdSet.exportKey(ENCRYPTION_PATH, false, false).checkOK().getData();
+        BIP32KeyPair encryptionKeyPair = BIP32KeyPair.fromTLV(tlvEncryption);
 
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+        ApplicationInfo info = cmdSet.getApplicationInfo();
+
+        WritableMap data = Arguments.createMap();
+        data.putString("whisper-address", Hex.toHexString(whisperKeyPair.toEthereumAddress()));
+        data.putString("whisper-public-key", Hex.toHexString(whisperKeyPair.getPublicKey()));
+        data.putString("whisper-private-key", Hex.toHexString(whisperKeyPair.getPrivateKey()));
+        data.putString("encryption-public-key", Hex.toHexString(encryptionKeyPair.getPublicKey()));
+        data.putString("instance-uid", Hex.toHexString(info.getInstanceUID()));
+        data.putString("key-uid", Hex.toHexString(info.getKeyUID()));
+
+        return data;
+    }
+
+    public WritableMap importKeys(final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         byte[] tlvEncryption = cmdSet.exportKey(ENCRYPTION_PATH, false, false).checkOK().getData();
         BIP32KeyPair encryptionKeyPair = BIP32KeyPair.fromTLV(tlvEncryption);
@@ -353,10 +363,10 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         byte[] tlvWhisper = cmdSet.exportKey(WHISPER_PATH, false, false).checkOK().getData();
         BIP32KeyPair whisperKeyPair = BIP32KeyPair.fromTLV(tlvWhisper);
 
-        byte[] tlvWallet = cmdSet.exportKey(WALLET_PATH, true, true).checkOK().getData();
+        byte[] tlvWallet = cmdSet.exportKey(WALLET_PATH, false, true).checkOK().getData();
         BIP32KeyPair walletKeyPair = BIP32KeyPair.fromTLV(tlvWallet);
 
-        ApplicationInfo info = new ApplicationInfo(cmdSet.select().checkOK().getData());
+        ApplicationInfo info = cmdSet.getApplicationInfo();
 
         WritableMap data = Arguments.createMap();
         data.putString("address", Hex.toHexString(masterPair.toEthereumAddress()));
@@ -375,18 +385,8 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         return data;
     }
 
-    public WritableMap generateAndLoadKey(final String mnemonic, final String pairingBase64, final String pin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+    public WritableMap generateAndLoadKey(final String mnemonic, final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         byte[] seed = Mnemonic.toBinarySeed(mnemonic, "");
         BIP32KeyPair keyPair = BIP32KeyPair.fromBinarySeed(seed);
@@ -406,7 +406,7 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         Log.i(TAG, "Derived " + ENCRYPTION_PATH);
         BIP32KeyPair encryptionKeyPair = BIP32KeyPair.fromTLV(tlvEncryption);
 
-        byte[] tlvWallet = cmdSet.exportKey(WALLET_PATH, true, true).checkOK().getData();
+        byte[] tlvWallet = cmdSet.exportKey(WALLET_PATH, false, true).checkOK().getData();
         Log.i(TAG, "Derived " + WALLET_PATH);
         BIP32KeyPair walletKeyPair = BIP32KeyPair.fromTLV(tlvWallet);
 
@@ -441,70 +441,46 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         return init(userPin);
     }
 
-    public int verifyPin(final String pairingBase64, final String pin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
-
-        ApplicationStatus status = new ApplicationStatus(cmdSet.getStatus(KeycardCommandSet.GET_STATUS_P1_APPLICATION).checkOK().getData());
-
-        return status.getPINRetryCount();
+    public int verifyPin(final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
+        return 3;
     }
 
-    public void changePin(final String pairingBase64, final String currentPin, final String newPin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
+    public void changePairingPassword(final String pin, final String pairingPassword) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
+        cmdSet.changePairingPassword(pairingPassword);
+        Log.i(TAG, "pairing password changed");
+    }
 
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
+    public void changePUK(final String pin, final String puk) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
-        cmdSet.verifyPIN(currentPin).checkOK();
-        Log.i(TAG, "pin verified");
+        cmdSet.changePUK(puk);
+        Log.i(TAG, "puk changed");
+    }
 
-        cmdSet.changePIN(0, newPin);
+    public void changePin(final String currentPin, final String newPin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(currentPin);
+
+        cmdSet.changePIN(newPin);
         Log.i(TAG, "pin changed");
     }
 
-    public void unblockPin(final String pairingBase64, final String puk, final String newPin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
+    public void unblockPin(final String puk, final String newPin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = securedCommandSet();
 
         cmdSet.unblockPIN(puk, newPin).checkOK();
         Log.i(TAG, "pin unblocked");
     }
 
-    public void unpair(final String pairingBase64, final String pin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+    public void unpair(final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         cmdSet.autoUnpair();
         Log.i(TAG, "card unpaired");
+        String instanceUID = Hex.toHexString(cmdSet.getApplicationInfo().getInstanceUID());
+        pairings.remove(instanceUID);
     }
 
     public void delete() throws IOException, APDUException {
@@ -518,45 +494,36 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         Log.i(TAG, "instance and package deleted");
     }
 
-    public void removeKey(final String pairingBase64, final String pin) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+    public void removeKey(final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         cmdSet.removeKey();
         Log.i(TAG, "key removed");
     }
 
-    public void removeKeyWithUnpair(final String pairingBase64, final String pin) throws IOException, APDUException {
-        removeKey(pairingBase64, pin);
-        unpair(pairingBase64, pin);
+    public void removeKeyWithUnpair(final String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
+
+        cmdSet.removeKey();
+        Log.i(TAG, "key removed");
+
+        cmdSet.unpairOthers();
+        Log.i(TAG, "unpaired others");
+
+        cmdSet.autoUnpair();
+        Log.i(TAG, "card unpaired");
+
+        String instanceUID = Hex.toHexString(cmdSet.getApplicationInfo().getInstanceUID());
+        pairings.remove(instanceUID);
     }
 
-    public void unpairAndDelete(final String pairingBase64, final String pin) throws IOException, APDUException {
-        unpair(pairingBase64, pin);
+    public void unpairAndDelete(final String pin) throws IOException, APDUException {
+        unpair(pin);
         delete();
     }
 
-    public String sign(final String pairingBase64, final String pin, final String message) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+    public String sign(final String pin, final String message) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         byte[] hash = Hex.decode(message);
         RecoverableSignature signature = new RecoverableSignature(hash, cmdSet.sign(hash).checkOK().getData());
@@ -578,18 +545,8 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
         return sig;
     }
 
-    public String signWithPath(final String pairingBase64, final String pin, final String path, final String message) throws IOException, APDUException {
-        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
-        cmdSet.select().checkOK();
-
-        Pairing pairing = new Pairing(pairingBase64);
-        cmdSet.setPairing(pairing);
-
-        cmdSet.autoOpenSecureChannel();
-        Log.i(TAG, "secure channel opened");
-
-        cmdSet.verifyPIN(pin).checkOK();
-        Log.i(TAG, "pin verified");
+    public String signWithPath(final String pin, final String path, final String message) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = authenticatedCommandSet(pin);
 
         byte[] hash = Hex.decode(message);
 
@@ -645,4 +602,46 @@ public class SmartCard extends BroadcastReceiver implements CardListener {
 
         return sig;
     }
+
+    public void setPairings(ReadableMap newPairings) {
+        pairings.clear();
+        Iterator<Map.Entry<String,Object>> i = newPairings.getEntryIterator();
+        while (i.hasNext()) {
+            Map.Entry<String, Object> entry = i.next();
+            String value = ((ReadableMap) entry.getValue()).getString("pairing");
+            pairings.put(entry.getKey(), value);
+        }
+    }
+
+    private KeycardCommandSet authenticatedCommandSet(String pin) throws IOException, APDUException {
+        KeycardCommandSet cmdSet = securedCommandSet();
+        cmdSet.verifyPIN(pin).checkOK();
+        Log.i(TAG, "pin verified");
+
+        return cmdSet;
+    }
+
+    private KeycardCommandSet securedCommandSet() throws IOException, APDUException {
+        KeycardCommandSet cmdSet = new KeycardCommandSet(this.cardChannel);
+        cmdSet.select().checkOK();
+        openSecureChannel(cmdSet);
+
+        return cmdSet;
+    }
+
+    private void openSecureChannel(KeycardCommandSet cmdSet) throws IOException, APDUException {
+        String instanceUID = Hex.toHexString(cmdSet.getApplicationInfo().getInstanceUID());
+        String pairingBase64 = pairings.get(instanceUID);
+
+        if (pairingBase64 == null) {
+            throw new APDUException("No pairing found");
+        }
+
+        Pairing pairing = new Pairing(pairingBase64);
+        cmdSet.setPairing(pairing);
+
+        cmdSet.autoOpenSecureChannel();
+        Log.i(TAG, "secure channel opened");
+    }
+
 }

android/src/main/java/im/status/ethereum/keycard/SmartCardSecrets.java

@@ -1,6 +1,5 @@
 package im.status.ethereum.keycard;
 
-import android.support.annotation.NonNull;
 import android.util.Base64;
 
 import static android.util.Base64.NO_PADDING;
@@ -29,9 +28,8 @@ public class SmartCardSecrets {
         this.pairingPassword = pairingPassword;
     }
 
-    @NonNull
     public static SmartCardSecrets generate(final String userPin) throws NoSuchAlgorithmException, InvalidKeySpecException {
-        String pairingPassword = randomToken(5);
+        String pairingPassword = "KeycardDefaultPairing";
         long pinNumber = randomLong(PIN_BOUND);
         long pukNumber = randomLong(PUK_BOUND);
 

ios/SmartCard.swift

@@ -4,6 +4,7 @@ import os.log
 
 enum SmartCardError: Error {
     case invalidBase64
+    case noPairing
 }
 
 enum DerivationPath: String {
@@ -15,13 +16,15 @@ enum DerivationPath: String {
 }
 
 class SmartCard {
+    var pairings: [String: String] = [:]
+
     func initialize(channel: CardChannel, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
       let puk = self.randomPUK()
-      let pairingPassword = self.randomPairingPassword();
+      let pairingPassword = "KeycardDefaultPairing"
 
       let cmdSet = KeycardCommandSet(cardChannel: channel)
       try cmdSet.select().checkOK()
-      try cmdSet.initialize(pin: pin, puk: puk, pairingPassword: pairingPassword).checkOK();
+      try cmdSet.initialize(pin: pin, puk: puk, pairingPassword: pairingPassword).checkOK()
 
       resolve(["pin": pin, "puk": puk, "password": pairingPassword])
     }
@@ -33,12 +36,13 @@ class SmartCard {
       logAppInfo(info)
 
       try cmdSet.autoPair(password: pairingPassword)
-
-      resolve(Data(cmdSet.pairing!.bytes).base64EncodedString())
+      let pairing = Data(cmdSet.pairing!.bytes).base64EncodedString()
+      self.pairings[bytesToHex(info.instanceUID)] = pairing
+      resolve(pairing)
     }
 
-    func generateMnemonic(channel: CardChannel, pairingBase64: String, words: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try securedCommandSet(channel: channel, pairingBase64: pairingBase64)
+    func generateMnemonic(channel: CardChannel, words: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try securedCommandSet(channel: channel)
 
       let mnemonic = try Mnemonic(rawData: cmdSet.generateMnemonic(length: GenerateMnemonicP1.length12Words).checkOK().data)
       mnemonic.wordList = words.components(separatedBy: .newlines)
@@ -46,8 +50,8 @@ class SmartCard {
       resolve(mnemonic.toMnemonicPhrase())
     }
 
-    func generateAndLoadKey(channel: CardChannel, mnemonic: String, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func generateAndLoadKey(channel: CardChannel, mnemonic: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       let seed = Mnemonic.toBinarySeed(mnemonicPhrase: mnemonic)
       let keyPair = BIP32KeyPair(fromSeed: seed)
 
@@ -77,15 +81,38 @@ class SmartCard {
       ])
     }
 
-    func saveMnemonic(channel: CardChannel, mnemonic: String, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func saveMnemonic(channel: CardChannel, mnemonic: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       let seed = Mnemonic.toBinarySeed(mnemonicPhrase: mnemonic)
       try cmdSet.loadKey(seed: seed).checkOK()
       os_log("seed loaded to card");
       resolve(true)
     }
 
-    func getApplicationInfo(channel: CardChannel, pairingBase64: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+    func factoryReset(channel: CardChannel, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet: GlobalPlatformCommandSet = GlobalPlatformCommandSet(cardChannel: channel);
+      try cmdSet.select().checkOK()
+      os_log("ISD selected")
+
+      try cmdSet.openSecureChannel()
+      os_log("SecureChannel opened")
+
+      try cmdSet.deleteKeycardInstance().checkSW(StatusWord.ok, StatusWord.referencedDataNotFound)
+      os_log("Keycard applet instance deleted")
+
+      try cmdSet.installKeycardInstance().checkOK()
+      os_log("Keycard applet instance re-installed")
+
+      let info = try ApplicationInfo(KeycardCommandSet(cardChannel: channel).select().checkOK().data)
+      os_log("Selecting the newly installed Keycard applet succeeded")
+
+      var cardInfo = [String: Any]()
+      cardInfo["initialized?"] = info.initializedCard
+
+      resolve(cardInfo)
+    }
+
+    func getApplicationInfo(channel: CardChannel, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
       let cmdSet = KeycardCommandSet(cardChannel: channel)
       let info = try ApplicationInfo(cmdSet.select().checkOK().data)
 
@@ -97,24 +124,26 @@ class SmartCard {
         logAppInfo(info)
         var isPaired = false
 
-        if (!pairingBase64.isEmpty) {
+        if let _ = self.pairings[bytesToHex(info.instanceUID)] {
           do {
-            try openSecureChannel(cmdSet: cmdSet, pairingBase64: pairingBase64)
+            try openSecureChannel(cmdSet: cmdSet)
             isPaired = true
           } catch let error as CardError {
-            os_log("autoOpenSecureChannel failed: %@", String(describing: error));
+            isPaired = try tryDefaultPairing(cmdSet: cmdSet, cardInfo: &cardInfo)
           } catch let error as StatusWord {
-            os_log("autoOpenSecureChannel failed: %@", String(describing: error));
+            isPaired = try tryDefaultPairing(cmdSet: cmdSet, cardInfo: &cardInfo)
           }
+        } else {
+          isPaired = try tryDefaultPairing(cmdSet: cmdSet, cardInfo: &cardInfo)
+        }
 
-          if (isPaired) {
-            let status = try ApplicationStatus(cmdSet.getStatus(info: GetStatusP1.application.rawValue).checkOK().data);
-            os_log("PIN retry counter: %d", status.pinRetryCount)
-            os_log("PUK retry counter: %d", status.pukRetryCount)
+        if (isPaired) {
+          let status = try ApplicationStatus(cmdSet.getStatus(info: GetStatusP1.application.rawValue).checkOK().data);
+          os_log("PIN retry counter: %d", status.pinRetryCount)
+          os_log("PUK retry counter: %d", status.pukRetryCount)
 
-            cardInfo["pin-retry-counter"] = status.pinRetryCount
-            cardInfo["puk-retry-counter"] = status.pukRetryCount
-          }
+          cardInfo["pin-retry-counter"] = status.pinRetryCount
+          cardInfo["puk-retry-counter"] = status.pukRetryCount
         }
 
         cardInfo["paired?"] = isPaired
@@ -130,8 +159,8 @@ class SmartCard {
       resolve(cardInfo)
     }
 
-    func deriveKey(channel: CardChannel, path: String, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func deriveKey(channel: CardChannel, path: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       let currentPath = try KeyPath(data: cmdSet.getStatus(info: GetStatusP1.keyPath.rawValue).checkOK().data);
       os_log("Current key path: %@", currentPath.description)
 
@@ -143,21 +172,21 @@ class SmartCard {
       resolve(true)
     }
 
-    func exportKey(channel: CardChannel, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func exportKey(channel: CardChannel, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       let key = try cmdSet.exportCurrentKey(publicOnly: true).checkOK().data
       resolve(bytesToHex(key))
     }
 
-    func exportKeyWithPath(channel: CardChannel, pairingBase64: String, pin: String, path: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func exportKeyWithPath(channel: CardChannel, pin: String, path: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       let key = try BIP32KeyPair(fromTLV: cmdSet.exportKey(path: path, makeCurrent: false, publicOnly: true).checkOK().data).publicKey;
 
       resolve(bytesToHex(key))
     }
 
-    func getKeys(channel: CardChannel, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func importKeys(channel: CardChannel, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
 
       let encryptionKeyPair = try exportKey(cmdSet: cmdSet, path: .encryptionPath, makeCurrent: false, publicOnly: false)
       let masterPair = try exportKey(cmdSet: cmdSet, path: .masterPath, makeCurrent: false, publicOnly: true)
@@ -165,7 +194,7 @@ class SmartCard {
       let whisperKeyPair = try exportKey(cmdSet: cmdSet, path: .whisperPath, makeCurrent: false, publicOnly: false)
       let walletKeyPair = try exportKey(cmdSet: cmdSet, path: .walletPath, makeCurrent: false, publicOnly: true)
 
-      let info = try ApplicationInfo(cmdSet.select().checkOK().data)
+      let info = cmdSet.info!
 
       resolve([
         "address": bytesToHex(masterPair.toEthereumAddress()),
@@ -183,14 +212,32 @@ class SmartCard {
       ])
     }
 
-    func sign(channel: CardChannel, pairingBase64: String, pin: String, message: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func getKeys(channel: CardChannel, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
+
+      let whisperKeyPair = try exportKey(cmdSet: cmdSet, path: .whisperPath, makeCurrent: false, publicOnly: false)
+      let encryptionKeyPair = try exportKey(cmdSet: cmdSet, path: .encryptionPath, makeCurrent: false, publicOnly: false)
+
+      let info = cmdSet.info!
+
+      resolve([
+        "whisper-address": bytesToHex(whisperKeyPair.toEthereumAddress()),
+        "whisper-public-key": bytesToHex(whisperKeyPair.publicKey),
+        "whisper-private-key": bytesToHex(whisperKeyPair.privateKey!),
+        "encryption-public-key": bytesToHex(encryptionKeyPair.publicKey),
+        "instance-uid": bytesToHex(info.instanceUID),
+        "key-uid": bytesToHex(info.keyUID)
+      ])
+    }
+
+    func sign(channel: CardChannel, pin: String, message: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       let sig = try processSignature(message) { return try cmdSet.sign(hash: $0) }
       resolve(sig)
     }
 
-    func signWithPath(channel: CardChannel, pairingBase64: String, pin: String, path: String, message: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func signWithPath(channel: CardChannel, pin: String, path: String, message: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       let sig = try processSignature(message) {
         if (cmdSet.info!.appVersion < 0x0202) {
           let currentPath = try KeyPath(data: cmdSet.getStatus(info: GetStatusP1.keyPath.rawValue).checkOK().data);
@@ -216,51 +263,70 @@ class SmartCard {
       resolve(sig)
     }
 
-    func verifyPin(channel: CardChannel, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
-      let status = try ApplicationStatus(cmdSet.getStatus(info: GetStatusP1.application.rawValue).checkOK().data);
-      resolve(status.pinRetryCount)
+    func verifyPin(channel: CardChannel, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let _ = try authenticatedCommandSet(channel: channel, pin: pin)
+      resolve(3)
     }
 
-    func changePin(channel: CardChannel, pairingBase64: String, currentPin: String, newPin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: currentPin)
+    func changePairingPassword(channel: CardChannel, pin: String, pairingPassword: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
+      try cmdSet.changePairingPassword(pairingPassword: pairingPassword).checkOK()
+      os_log("pairing password changed")
+      resolve(true)
+    }
+
+    func changePUK(channel: CardChannel, pin: String, puk: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
+      try cmdSet.changePUK(puk: puk).checkOK()
+      os_log("puk changed")
+      resolve(true)
+    }
+
+    func changePin(channel: CardChannel, currentPin: String, newPin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: currentPin)
       try cmdSet.changePIN(pin: newPin).checkOK()
       os_log("pin changed")
       resolve(true)
     }
 
-    func unblockPin(channel: CardChannel, pairingBase64: String, puk: String, newPin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try securedCommandSet(channel: channel, pairingBase64: pairingBase64)
+    func unblockPin(channel: CardChannel, puk: String, newPin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try securedCommandSet(channel: channel)
       try cmdSet.unblockPIN(puk: puk, newPIN: newPin).checkAuthOK()
       os_log("pin unblocked")
       resolve(true)
     }
 
-    func unpair(channel: CardChannel, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func unpair(channel: CardChannel, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
 
       try cmdSet.autoUnpair()
       os_log("card unpaired")
 
+      self.pairings[bytesToHex(cmdSet.info!.instanceUID)] = nil
       resolve(true)
     }
 
-    func removeKey(channel: CardChannel, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func removeKey(channel: CardChannel, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       try cmdSet.removeKey().checkOK()
       os_log("key removed")
 
       resolve(true)
     }
 
-    func removeKeyWithUnpair(channel: CardChannel, pairingBase64: String, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
-      let cmdSet = try authenticatedCommandSet(channel: channel, pairingBase64: pairingBase64, pin: pin)
+    func removeKeyWithUnpair(channel: CardChannel, pin: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) throws -> Void {
+      let cmdSet = try authenticatedCommandSet(channel: channel, pin: pin)
       try cmdSet.removeKey().checkOK()
       os_log("key removed")
 
+      try cmdSet.unpairOthers()
+      os_log("unpaired others")
+
       try cmdSet.autoUnpair()
       os_log("card unpaired")
 
+      self.pairings[bytesToHex(cmdSet.info!.instanceUID)] = nil
+
       resolve(true)
     }
 
@@ -280,27 +346,58 @@ class SmartCard {
       return try BIP32KeyPair(fromTLV: tlvRoot)
     }
 
-    func authenticatedCommandSet(channel: CardChannel, pairingBase64: String, pin: String) throws -> KeycardCommandSet {
-      let cmdSet = try securedCommandSet(channel: channel, pairingBase64: pairingBase64)
+    func setPairings(newPairings: NSDictionary, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
+      self.pairings.removeAll()
+      for case let (instanceUID as String, v as NSDictionary) in newPairings {
+        self.pairings[instanceUID] = v["pairing"] as? String
+      }
+
+      resolve(true)
+    }
+
+    func authenticatedCommandSet(channel: CardChannel, pin: String) throws -> KeycardCommandSet {
+      let cmdSet = try securedCommandSet(channel: channel)
       try cmdSet.verifyPIN(pin: pin).checkAuthOK()
       os_log("pin verified")
 
       return cmdSet;
     }
 
-    func securedCommandSet(channel: CardChannel, pairingBase64: String) throws -> KeycardCommandSet {
+    func securedCommandSet(channel: CardChannel) throws -> KeycardCommandSet {
       let cmdSet = KeycardCommandSet(cardChannel: channel)
       try cmdSet.select().checkOK()
-      try openSecureChannel(cmdSet: cmdSet, pairingBase64: pairingBase64)
+      try openSecureChannel(cmdSet: cmdSet)
 
       return cmdSet
     }
 
-    func openSecureChannel(cmdSet: KeycardCommandSet, pairingBase64: String) throws -> Void {
-      cmdSet.pairing = try base64ToPairing(pairingBase64)
+    func tryDefaultPairing(cmdSet: KeycardCommandSet, cardInfo: inout [String: Any]) throws -> Bool {
+      do {
+        try cmdSet.autoPair(password: "KeycardDefaultPairing")
+        let pairing = Data(cmdSet.pairing!.bytes).base64EncodedString()
+        self.pairings[bytesToHex(cmdSet.info!.instanceUID)] = pairing
+        cardInfo["new-pairing"] = pairing
 
-      try cmdSet.autoOpenSecureChannel()
-      os_log("secure channel opened")
+        try openSecureChannel(cmdSet: cmdSet)
+        return true
+      } catch let error as CardError {
+        os_log("autoOpenSecureChannel failed: %@", String(describing: error));
+      } catch let error as StatusWord {
+        os_log("autoOpenSecureChannel failed: %@", String(describing: error));
+      }
+
+      return false
+    }
+
+    func openSecureChannel(cmdSet: KeycardCommandSet) throws -> Void {
+      if let pairingBase64 = self.pairings[bytesToHex(cmdSet.info!.instanceUID)] {
+        cmdSet.pairing = try base64ToPairing(pairingBase64)
+
+        try cmdSet.autoOpenSecureChannel()
+        os_log("secure channel opened")
+      } else {
+        throw SmartCardError.noPairing
+      }
     }
 
     func processSignature(_ message: String, sign: ([UInt8]) throws -> APDUResponse) throws -> String {

ios/StatusKeycard.m

@@ -8,29 +8,34 @@ RCT_EXTERN_METHOD(nfcIsEnabled:(RCTPromiseResolveBlock)resolve reject: (RCTPromi
 RCT_EXTERN_METHOD(openNfcSettings:(RCTPromiseResolveBlock)resolve reject: (RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(init:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(pair:(NSString *)pairingPassword resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(generateMnemonic:(NSString *)pairing words:(NSString *)words resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(generateAndLoadKey:(NSString *)mnemonic pairing: (NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(saveMnemonic:(NSString *)mnemonic pairing: (NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(getApplicationInfo:(NSString *)pairingBase64 resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(deriveKey:(NSString *)path pairing: (NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(exportKey:(NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(exportKeyWithPath:(NSString *)pairing pin:(NSString *)pin path:(NSString *)path resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(getKeys:(NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(sign:(NSString *)pairing pin:(NSString *)pin hash:(NSString *)hash resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(signWithPath:(NSString *)pairing pin:(NSString *)pin path:(NSString *)path hash:(NSString *)hash resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(generateMnemonic:(NSString *)words resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(generateAndLoadKey:(NSString *)mnemonic pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(saveMnemonic:(NSString *)mnemonic pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getApplicationInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(factoryReset:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(deriveKey:(NSString *)path pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(exportKey:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(exportKeyWithPath:(NSString *)pin path:(NSString *)path resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(importKeys:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getKeys:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(sign:(NSString *)pin hash:(NSString *)hash resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(signWithPath:(NSString *)pin path:(NSString *)path hash:(NSString *)hash resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(signPinless:(NSString *)hash resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(installApplet:(RCTPromiseResolveBlock)resolve reject: (RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(installAppletAndInitCard:(String *)pin resolve: (RCTPromiseResolveBlock)resolve reject: (RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(verifyPin:(NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(changePin:(NSString *)pairing currentPin:(NSString *)currentPin newPin:(NSString *)newPin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(unblockPin:(NSString *)pairing puk:(NSString *)puk newPin:(NSString *)newPin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(unpair:(NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(verifyPin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(changePairingPassword:(NSString *)pin pairingPassword:(NSString *)pairingPassword resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(changePUK:(NSString *)pin puk:(NSString *)puk resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(changePin:(NSString *)currentPin newPin:(NSString *)newPin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(unblockPin:(NSString *)puk newPin:(NSString *)newPin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(unpair:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(delete:(RCTPromiseResolveBlock)resolve reject: (RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(removeKey:(NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(removeKeyWithUnpair:(NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
-RCT_EXTERN_METHOD(unpairAndDelete:(NSString *)pairing pin:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(removeKey:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(removeKeyWithUnpair:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(unpairAndDelete:(NSString *)pin resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(startNFC:(NSString *)prompt resolve:(RCTPromiseResolveBlock)resolve reject: (RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(stopNFC:(NSString *)err resolve:(RCTPromiseResolveBlock)resolve reject: (RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(setNFCMessage:(NSString *)message resolve:(RCTPromiseResolveBlock)resolve reject: (RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setPairings:(NSDictionary *)pairings resolve:(RCTPromiseResolveBlock)resolve reject: (RCTPromiseRejectBlock)reject)
 
 @end

ios/StatusKeycard.swift

@@ -9,8 +9,18 @@ class StatusKeycard: RCTEventEmitter {
     var cardChannel: CardChannel? = nil
     var nfcStartPrompt: String = "Hold your iPhone near a Status Keycard."
 
+    private var _keycardController: Any? = nil
+    
     @available(iOS 13.0, *)
-    private(set) lazy var keycardController: KeycardController? = nil
+    private var keycardController: KeycardController? {
+      get {
+        return _keycardController as? KeycardController
+      }
+
+      set(kc) {
+        _keycardController = kc
+      }
+    }
 
     @objc
     func nfcIsSupported(_ resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
@@ -44,53 +54,63 @@ class StatusKeycard: RCTEventEmitter {
     }
 
     @objc
-    func generateMnemonic(_ pairing: String, words: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.generateMnemonic(channel: channel, pairingBase64: pairing, words: words, resolve: resolve, reject: reject) }
+    func generateMnemonic(_ words: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.generateMnemonic(channel: channel, words: words, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func generateAndLoadKey(_ mnemonic: String, pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.generateAndLoadKey(channel: channel, mnemonic: mnemonic, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func generateAndLoadKey(_ mnemonic: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.generateAndLoadKey(channel: channel, mnemonic: mnemonic, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func saveMnemonic(_ mnemonic: String, pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.saveMnemonic(channel: channel, mnemonic: mnemonic, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func saveMnemonic(_ mnemonic: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.saveMnemonic(channel: channel, mnemonic: mnemonic, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func getApplicationInfo(_ pairingBase64: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.getApplicationInfo(channel: channel, pairingBase64: pairingBase64, resolve: resolve, reject: reject) }
+    func factoryReset(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.factoryReset(channel: channel, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func deriveKey(_ path: String, pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.deriveKey(channel: channel, path: path, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func getApplicationInfo(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.getApplicationInfo(channel: channel, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func exportKey(_ pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.exportKey(channel: channel, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func deriveKey(_ path: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.deriveKey(channel: channel, path: path, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func exportKeyWithPath(_ pairing: String, pin: String, path: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.exportKeyWithPath(channel: channel, pairingBase64: pairing, pin: pin, path: path, resolve: resolve, reject: reject) }
+    func exportKey(_ pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.exportKey(channel: channel, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func getKeys(_ pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.getKeys(channel: channel, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func exportKeyWithPath(_ pin: String, path: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.exportKeyWithPath(channel: channel, pin: pin, path: path, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func sign(_ pairing: String, pin: String, hash: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.sign(channel: channel, pairingBase64: pairing, pin: pin, message: hash, resolve: resolve, reject: reject) }
+    func importKeys(_ pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.importKeys(channel: channel, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func signWithPath(_ pairing: String, pin: String, path: String, hash: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.signWithPath(channel: channel, pairingBase64: pairing, pin: pin, path: path, message: hash, resolve: resolve, reject: reject) }
+    func getKeys(_ pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.getKeys(channel: channel, pin: pin, resolve: resolve, reject: reject) }
+    }
+
+    @objc
+    func sign(_ pin: String, hash: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.sign(channel: channel, pin: pin, message: hash, resolve: resolve, reject: reject) }
+    }
+
+    @objc
+    func signWithPath(_ pin: String, path: String, hash: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.signWithPath(channel: channel, pin: pin, path: path, message: hash, resolve: resolve, reject: reject) }
     }
 
     @objc
@@ -109,23 +129,33 @@ class StatusKeycard: RCTEventEmitter {
     }
 
     @objc
-    func verifyPin(_ pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.verifyPin(channel: channel, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func verifyPin(_ pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.verifyPin(channel: channel, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func changePin(_ pairing: String, currentPin: String, newPin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.changePin(channel: channel, pairingBase64: pairing, currentPin: currentPin, newPin: newPin, resolve: resolve, reject: reject) }
+    func changePairingPassword(_ pin: String, pairingPassword: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.changePairingPassword(channel: channel, pin: pin, pairingPassword: pairingPassword, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func unblockPin(_ pairing: String, puk: String, newPin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.unblockPin(channel: channel, pairingBase64: pairing, puk: puk, newPin: newPin, resolve: resolve, reject: reject) }
+    func changePUK(_ pin: String, puk: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.changePUK(channel: channel, pin: pin, puk: puk, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func unpair(_ pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.unpair(channel: channel, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func changePin(_ currentPin: String, newPin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.changePin(channel: channel, currentPin: currentPin, newPin: newPin, resolve: resolve, reject: reject) }
+    }
+
+    @objc
+    func unblockPin(_ puk: String, newPin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.unblockPin(channel: channel, puk: puk, newPin: newPin, resolve: resolve, reject: reject) }
+    }
+
+    @objc
+    func unpair(_ pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.unpair(channel: channel, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
@@ -134,20 +164,25 @@ class StatusKeycard: RCTEventEmitter {
     }
 
     @objc
-    func removeKey(_ pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.removeKey(channel: channel, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func removeKey(_ pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.removeKey(channel: channel, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func removeKeyWithUnpair(_ pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.removeKeyWithUnpair(channel: channel, pairingBase64: pairing, pin: pin, resolve: resolve, reject: reject) }
+    func removeKeyWithUnpair(_ pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      keycardInvokation(reject) { [unowned self] channel in try self.smartCard.removeKeyWithUnpair(channel: channel, pin: pin, resolve: resolve, reject: reject) }
     }
 
     @objc
-    func unpairAndDelete(_ pairing: String, pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    func unpairAndDelete(_ pin: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
       reject("E_KEYCARD", "Not implemented (unused)", nil)
     }
 
+    @objc
+    func setPairings(_ pairings: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+      self.smartCard.setPairings(newPairings: pairings, resolve: resolve, reject: reject)
+    }
+
     @objc
     func startNFC(_ prompt: String, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
       if #available(iOS 13.0, *) {
@@ -174,7 +209,7 @@ class StatusKeycard: RCTEventEmitter {
               let nsError = error as NSError
               if nsError.code == 200 && nsError.domain == "NFCError" {
                 self.sendEvent(withName: "keyCardOnNFCUserCancelled", body: nil)
-              } else if nsError.code == 201 && nsError.domain == "NFCError" {
+              } else if (nsError.code == 201 || nsError.code == 203) && (nsError.domain == "NFCError") {
                 self.sendEvent(withName: "keyCardOnNFCTimeout", body: nil)
               }
             }

package.json

@@ -1,8 +1,8 @@
 {
   "name": "react-native-status-keycard",
   "homepage": "https://keycard.status.im/",
-  "version": "2.5.29",
-  "description": "React Native library to interact with Status Keycard using NFC connection (Android only)",
+  "version": "2.5.38",
+  "description": "React Native library to interact with Status Keycard using NFC connection",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"