@readyio/react-native-wallet 0.1.8

package/android/src/main/java/com/readyio/readywallet/ReadyWalletActivity.java

@@ -0,0 +1,192 @@
+package com.readyio.readywallet;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.util.Log;
+
+import com.bitgo.randombytes.RandomBytesPackage;
+import com.facebook.hermes.reactexecutor.HermesExecutorFactory;
+import com.facebook.react.ReactActivity;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.ReactRootView;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.LifecycleState;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.shell.MainReactPackage;
+import com.gzip.GzipPackage;
+import com.horcrux.svg.SvgPackage;
+import com.learnium.RNDeviceInfo.RNDeviceInfo;
+import com.nozbe.watermelondb.WatermelonDBPackage;
+import com.oblador.keychain.KeychainPackage;
+import com.reactnativecommunity.asyncstorage.AsyncStoragePackage;
+import com.reactnativecommunity.cameraroll.CameraRollPackage;
+import com.reactnativecommunity.clipboard.ClipboardPackage;
+import com.reactnativecommunity.netinfo.NetInfoPackage;
+
+import com.readyio.readywallet.splash.ReadySplash;
+import com.rnbiometrics.ReactNativeBiometricsPackage;
+import com.rnfs.RNFSPackage;
+import com.swmansion.gesturehandler.RNGestureHandlerPackage;
+import com.swmansion.reanimated.ReanimatedPackage;
+import com.th3rdwave.safeareacontext.SafeAreaContextPackage;
+import com.walletconnect.reactnativemodule.RNWalletConnectModulePackage;
+import org.linusu.RNGetRandomValuesPackage;
+import org.reactnative.camera.RNCameraPackage;
+import com.reactnativecommunity.webview.RNCWebViewPackage;
+import com.reactcommunity.rndatetimepicker.RNDateTimePickerPackage;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import cl.json.RNSharePackage;
+import io.invertase.firebase.analytics.ReactNativeFirebaseAnalyticsPackage;
+import io.invertase.firebase.app.ReactNativeFirebaseAppPackage;
+import io.sentry.react.RNSentryPackage;
+
+public class ReadyWalletActivity extends ReactActivity implements DefaultHardwareBackBtnHandler {
+    public static final String BROASCAST_EVENT = "android.intent.action.ready.wallet";
+    public static final String PUSH_EVENT_NAME = "ReadyWallet_FOREGROUND_PUSH_EVENT";
+    public static final String DEEPLINK_EVENT_NAME = "ReadyWallet_FOREGROUND_DEEPLINK_EVENT";
+    public static Boolean isLaunch = false;
+    private static ReadyWalletActivity mInstance;
+    private ReactRootView mReactRootView;
+    private ReactInstanceManager mReactInstanceManager;
+
+    private BroadcastReceiver myReceiver = new BroadcastReceiver() {
+      @Override
+      public void onReceive(Context context, Intent intent) {
+        String action = intent.getAction();
+        if (BROASCAST_EVENT.equals(action)) {
+          Bundle bundle  = intent.getBundleExtra("data");
+          String type = intent.getStringExtra("type");
+          WritableMap params = Arguments.createMap();
+          if (type != null && type.equals(DEEPLINK_EVENT_NAME)){
+            params.putString("deepLinkUrl", bundle.getString("deepLinkUrl"));
+          }
+          if (type != null && type.equals(PUSH_EVENT_NAME)){
+            params.putString("event", bundle.getString("event"));
+            params.putString("destination", bundle.getString("destination"));
+            params.putString("data", bundle.getString("data"));
+          }
+          sendEvent(type, params);
+        }
+      }
+    };
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        ReadySplash.show(this, true);// ⬅️ initialize the splash screen
+        super.onCreate(savedInstanceState);
+        mInstance = this;
+        Bundle bundle = getIntent().getExtras();
+        assert bundle != null;
+        Bundle initProps = bundle.getBundle("initProps");
+        mReactRootView = new ReactRootView(this);
+
+        mReactInstanceManager = ReactInstanceManager.builder()
+                .setApplication(getApplication())
+                .setJavaScriptExecutorFactory(new HermesExecutorFactory())
+                .setCurrentActivity(this)
+                .setBundleAssetName("ReadyWallet.bundle")
+                .setJSMainModulePath("index")
+                .addPackages(getPackages())
+                .setUseDeveloperSupport(false)
+                .setInitialLifecycleState(LifecycleState.RESUMED)
+                .build();
+        mReactRootView.startReactApplication(mReactInstanceManager, "ReadyWallet", initProps);
+        setContentView(mReactRootView);
+
+        // Register the receiver
+        registerReceiver(myReceiver, new IntentFilter(BROASCAST_EVENT));
+        isLaunch= true;
+    }
+
+    // Use the context to send events
+    private void sendEvent(String type, WritableMap params) {
+      mReactRootView.getReactInstanceManager().getCurrentReactContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+          .emit(type, params);
+    }
+
+    public ArrayList<ReactPackage> getPackages() {
+        return new ArrayList<>(Arrays.asList(
+                new MainReactPackage(),
+                new ReadyWalletPackage(),
+                new RNGestureHandlerPackage(),
+                new AsyncStoragePackage(),
+                new SafeAreaContextPackage(),
+                new NetInfoPackage(),
+                new RNSharePackage(),
+                new ReanimatedPackage(),
+                new ClipboardPackage(),
+                new RNFSPackage(),
+                new RNDeviceInfo(),
+                new ReactNativeBiometricsPackage(),
+                new RandomBytesPackage(),
+                new RNGetRandomValuesPackage(),
+                new WatermelonDBPackage(),
+                new RNCameraPackage(),
+                new SvgPackage(),
+                new KeychainPackage(),
+                new CameraRollPackage(),
+                new RNSentryPackage(),
+                new RNWalletConnectModulePackage(),
+                new RNCWebViewPackage(),
+                new RNDateTimePickerPackage(),
+                new ReactNativeFirebaseAppPackage(),
+                new ReactNativeFirebaseAnalyticsPackage(),
+                new GzipPackage()
+        ));
+    }
+    public static void close() {
+        if (mInstance != null) mInstance.finish();
+        mInstance = null;
+    }
+    @Override
+    protected void onPause() {
+        super.onPause();
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onHostPause(this);
+        }
+    }
+    @Override
+    protected void onResume() {
+        super.onResume();
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onHostResume(this, this);
+        }
+    }
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        isLaunch= false;
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onHostDestroy(this);
+        }
+        if (mReactRootView != null) {
+            mReactRootView.unmountReactApplication();
+        }
+        unregisterReceiver(myReceiver);
+    }
+    @Override
+    public void invokeDefaultOnBackPressed() {
+      super.onBackPressed();
+    }
+    @Override
+    public void onBackPressed() {
+        if (mReactInstanceManager != null) {
+            mReactInstanceManager.onBackPressed();
+        } else {
+            super.onBackPressed();
+        }
+    }
+}

package/android/src/main/java/com/readyio/readywallet/ReadyWalletModule.java

@@ -0,0 +1,68 @@
+package com.readyio.readywallet;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+
+@ReactModule(name = ReadyWalletModule.NAME)
+public class ReadyWalletModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "ReadyWallet";
+  private ReactApplicationContext reactContext;
+
+  public ReadyWalletModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+  }
+
+  @ReactMethod
+  public void getIsLaunch(Promise promise) {
+    promise.resolve(ReadyWalletActivity.isLaunch);
+  }
+
+  public void sendEvent(String type, ReadableMap params) {
+      Intent intent = new Intent(ReadyWalletActivity.BROASCAST_EVENT);
+      intent.putExtra("data", Arguments.toBundle(params));
+      intent.putExtra("type", type);
+      this.reactContext.sendBroadcast(intent);
+  }
+
+  @ReactMethod
+  public void sendPushDataEvent(ReadableMap params) {
+    this.sendEvent(ReadyWalletActivity.PUSH_EVENT_NAME, params);
+  }
+
+  @ReactMethod
+  public void sendDeeplinkDataEvent(ReadableMap params) {
+    this.sendEvent(ReadyWalletActivity.DEEPLINK_EVENT_NAME, params);
+  }
+
+  @ReactMethod
+  public void openApp(ReadableMap initProps) {
+    Intent intent = new Intent(reactContext, ReadyWalletActivity.class);
+    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    Bundle bundle = new Bundle();
+    bundle.putBundle("initProps", Arguments.toBundle(initProps));
+    intent.putExtras(bundle);
+    reactContext.startActivity(intent);
+  }
+
+  @ReactMethod
+  public void closeApp() {
+    ReadyWalletActivity.close();
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+}

package/android/src/main/java/com/readyio/readywallet/ReadyWalletPackage.java

@@ -0,0 +1,34 @@
+package com.readyio.readywallet;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.readyio.readywallet.crypto.EncryptionModule;
+import com.readyio.readywallet.crypto.GenerateKeyAndAddress;
+import com.readyio.readywallet.splash.ReadySplashModule;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ReadyWalletPackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new ReadyWalletModule(reactContext));
+    modules.add(new EncryptionModule(reactContext));
+    modules.add(new GenerateKeyAndAddress(reactContext));
+    modules.add(new ReadySplashModule(reactContext));
+    return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/android/src/main/java/com/readyio/readywallet/crypto/EncryptionModule.java

@@ -0,0 +1,95 @@
+package com.readyio.readywallet.crypto;
+
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.web3j.abi.datatypes.generated.Bytes32;
+import org.web3j.utils.Numeric;
+import org.whispersystems.curve25519.Curve25519;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.Collections;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.KeyGenerator;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.IvParameterSpec;
+
+public class EncryptionModule extends ReactContextBaseJavaModule {
+    public EncryptionModule(ReactApplicationContext reactApplicationContext){
+        super(reactApplicationContext);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "ReadyEncryptionModule";
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String encryptFile(String inputFile, String outputFile) throws IOException, NoSuchPaddingException,
+            NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException,
+            BadPaddingException, IllegalBlockSizeException, JSONException {
+        byte[] iv_byte = new byte[16];
+        new SecureRandom().nextBytes(iv_byte);
+        IvParameterSpec iv = new IvParameterSpec(iv_byte);
+        SecretKey secretKey = KeyGenerator.getInstance("AES").generateKey();
+
+        String encodedKey = Base64.getEncoder().encodeToString(secretKey.getEncoded());
+        String encodeIv = Base64.getEncoder().encodeToString(iv_byte);
+
+        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
+        cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
+        FileInputStream inputStream = new FileInputStream(inputFile);
+        FileOutputStream outputStream = new FileOutputStream(outputFile);
+
+        byte[] buffer = new byte[1024 * 256];
+        int bytesRead;
+        while ((bytesRead = inputStream.read(buffer)) != -1) {
+            byte[] output = cipher.update(buffer, 0, bytesRead);
+            if (output != null) {
+                outputStream.write(output);
+            }
+        }
+
+        byte[] outputBytes = cipher.doFinal();
+        if (outputBytes != null) {
+            outputStream.write(outputBytes);
+        }
+        inputStream.close();
+        outputStream.close();
+        JSONObject crypto = new JSONObject();
+        crypto.put("key", encodedKey);
+        crypto.put("iv",encodeIv);
+        return crypto.toString();
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String signCurve25519(String privateKey, String message ) {
+        Curve25519 cipher = Curve25519.getInstance(Curve25519.BEST);
+        byte[] myStringInByte = Numeric.hexStringToByteArray(privateKey);
+        byte[] signature = cipher.calculateSignature(myStringInByte, message.getBytes());
+        return Arrays.toString(signature);
+    }
+}

package/android/src/main/java/com/readyio/readywallet/crypto/GenerateKeyAndAddress.java

@@ -0,0 +1,63 @@
+package com.readyio.readywallet.crypto;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+import org.bitcoinj.crypto.ChildNumber;
+import org.bitcoinj.crypto.DeterministicKey;
+import org.bitcoinj.crypto.HDUtils;
+import org.bitcoinj.wallet.DeterministicKeyChain;
+import org.bitcoinj.wallet.DeterministicSeed;
+import org.bitcoinj.wallet.UnreadableWalletException;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.web3j.crypto.Credentials;
+
+import java.math.BigInteger;
+import java.util.List;
+
+public class GenerateKeyAndAddress extends ReactContextBaseJavaModule {
+
+    public GenerateKeyAndAddress(ReactApplicationContext reactApplicationContext){
+        super(reactApplicationContext);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "ReadyGenerateKeyAndAddress";
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String generateKeyAndAddress(String passphrase, String path) {
+        JSONObject processJson = new JSONObject();
+        try {
+            DeterministicSeed seed = new DeterministicSeed(passphrase, null, "", 1409478661L);
+            DeterministicKeyChain chain = DeterministicKeyChain.builder().seed(seed).build();
+            List<ChildNumber> keyPath = HDUtils.parsePath("M/44H/60H/0H/0/0");
+            DeterministicKey key = chain.getKeyByPath(keyPath, true);
+            BigInteger privateKey = key.getPrivKey();
+            String privKey = key.getPrivateKeyAsHex();
+            BigInteger privkey = new BigInteger(privKey, 16);
+            byte[] bytes = org.bitcoinj.core.ECKey.publicKeyFromPrivate(privkey, false);
+            String publicKey = new BigInteger(1, bytes).toString(16);
+            while(publicKey.length() < 130){
+                publicKey = "0" + publicKey;
+            }
+            Credentials credentials = Credentials.create(privateKey.toString(16));
+
+            processJson.put("address", credentials.getAddress());
+            processJson.put("privateKey", "0x" + privKey);
+            processJson.put("publicKey", "0x" + publicKey);
+        } catch (JSONException e) {
+            return null;
+        } catch (UnreadableWalletException e) {
+            return null;
+        }
+
+        return processJson.toString();
+    }
+}

package/android/src/main/java/com/readyio/readywallet/splash/ReadySplash.java

@@ -0,0 +1,88 @@
+package com.readyio.readywallet.splash;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.os.Build;
+import android.view.WindowManager;
+
+import com.readyio.ReadyWallet.R;
+
+import java.lang.ref.WeakReference;
+
+public class ReadySplash {
+  private static Dialog mSplashDialog;
+  private static WeakReference<Activity> mActivity;
+
+  public static void show(final Activity activity, final int themeResId, final boolean fullScreen) {
+    if (activity == null) return;
+    mActivity = new WeakReference<Activity>(activity);
+    activity.runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        if (!activity.isFinishing()) {
+          mSplashDialog = new Dialog(activity, themeResId);
+          mSplashDialog.setContentView(R.layout.ready_splash);
+          mSplashDialog.setCancelable(false);
+          if (fullScreen) {
+            setActivityAndroidP(mSplashDialog);
+          }
+          if (!mSplashDialog.isShowing()) {
+            mSplashDialog.show();
+          }
+        }
+      }
+    });
+  }
+
+  public static void show(final Activity activity, final boolean fullScreen) {
+    int resourceId = fullScreen ? R.style.SplashScreen_Fullscreen : R.style.SplashScreen_SplashTheme;
+
+    show(activity, resourceId, fullScreen);
+  }
+
+  public static void show(final Activity activity) {
+    show(activity, false);
+  }
+
+  public static void hide(Activity activity) {
+    if (activity == null) {
+      if (mActivity == null) {
+        return;
+      }
+      activity = mActivity.get();
+    }
+
+    if (activity == null) return;
+
+    final Activity _activity = activity;
+
+    _activity.runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        if (mSplashDialog != null && mSplashDialog.isShowing()) {
+          boolean isDestroyed = false;
+
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            isDestroyed = _activity.isDestroyed();
+          }
+
+          if (!_activity.isFinishing() && !isDestroyed) {
+            mSplashDialog.dismiss();
+          }
+          mSplashDialog = null;
+        }
+      }
+    });
+  }
+
+  private static void setActivityAndroidP(Dialog dialog) {
+    if (Build.VERSION.SDK_INT >= 28) {
+      if (dialog != null && dialog.getWindow() != null) {
+        dialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);//全屏显示
+        WindowManager.LayoutParams lp = dialog.getWindow().getAttributes();
+        lp.layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
+        dialog.getWindow().setAttributes(lp);
+      }
+    }
+  }
+}

package/android/src/main/java/com/readyio/readywallet/splash/ReadySplashModule.java

@@ -0,0 +1,26 @@
+package com.readyio.readywallet.splash;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+public class ReadySplashModule extends ReactContextBaseJavaModule{
+  public ReadySplashModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return "ReadyWalletSplash";
+  }
+
+  @ReactMethod
+  public void show() {
+    ReadySplash.show(getCurrentActivity());
+  }
+
+  @ReactMethod
+  public void hide() {
+    ReadySplash.hide(getCurrentActivity());
+  }
+}