Feature/tron

.gitignore

@@ -156,3 +156,9 @@ fastlane/test_output
 .DS_Store
 
 libconnector.a
+
+
+tools/ios-internal-release.sh
+tools/android-internal-release.sh
+ios-release/**
+mobile-sdk/imKeyCoreX/Products/

Cargo.toml

@@ -9,4 +9,6 @@ members = [
     "wallet/coin-ethereum",
     "wallet/coin-eos",
     "wallet/coin-cosmos",
+    "wallet/coin-tron",
+    "wallet/coin-substrate",
 ]

Makefile

@@ -0,0 +1,49 @@
+SHELL := /bin/bash
+
+.PHONY: test
+
+help: ##@other show help
+	@perl -e '$(HELP_FUN)' $(MAKEFILE_LIST)
+
+# This is a code for automatic help generator.
+# To add new item into help output, simply add comments
+# starting with '##'. To add category, use @category.
+GREEN  := $(shell tput -Txterm setaf 2)
+WHITE  := $(shell tput -Txterm setaf 7)
+YELLOW := $(shell tput -Txterm setaf 3)
+RESET  := $(shell tput -Txterm sgr0)
+HELP_FUN = \
+	%help; \
+	while(<>) { push @{$$help{$$2 // 'options'}}, [$$1, $$3] if /^([a-zA-Z0-9\-]+)\s*:.*\#\#(?:@([a-zA-Z0-9\-]+))?\s(.*)$$/ }; \
+	print "Usage: make [target]\n\n"; \
+	for (sort keys %help) { \
+		print "${WHITE}$$_:${RESET}\n"; \
+		for (@{$$help{$$_}}) { \
+			$$sep = " " x (32 - length $$_->[0]); \
+			print "  ${YELLOW}$$_->[0]${RESET}$$sep${GREEN}$$_->[1]${RESET}\n"; \
+		}; \
+		print "\n"; \
+	}
+
+build-ios-example: ##@build generate the iOS compiled file
+	./tools/ios-example-build.sh
+
+build-ios-rn-example: ##@build generate the iOS RN compiled file
+	sh ./tools/ios-rn-example-build.sh
+
+build-android-rn-example: ##@build generate the Android RN compiled file
+	sh ./tools/android-rn-example-build.sh
+
+internal-release-android:
+	./tools/android-token-v2-build.sh
+
+internal-release-ios: ##@build generate the Android RN compiled file
+	sh ./tools/ios-framework-build.sh
+	sh ./tools/ios-internal-release.sh $(VER)
+
+e2e: ##@test run e2e test
+	(cd examples/RN && yarn)
+	(cd examples/RN/ios && pod install)
+	(cd examples/RN && yarn pbjs)
+	(cd examples/RN && yarn e2e)
+

api/Cargo.toml

@@ -16,8 +16,11 @@ coin-ethereum = {path = "../wallet/coin-ethereum"}
 coin-bitcoin = {path = "../wallet/coin-bitcoin"}
 coin-eos = {path = "../wallet/coin-eos"}
 coin-cosmos = {path = "../wallet/coin-cosmos"}
+coin-tron = {path = "../wallet/coin-tron"}
+coin-filecoin = {path = "../wallet/coin-filecoin"}
+coin-substrate = {path = "../wallet/coin-substrate"}
 common = {path = "../common"}
-bitcoin = "0.21.0"
+bitcoin = "0.25.0"
 ethereum-types = "0.6.0"
 prost = "0.6.1"
 bytes = "0.5.4"
@@ -26,7 +29,18 @@ hex = "0.4.2"
 failure = "0.1.8"
 linked-hash-map = { version = "0.5.3", features = ["serde_impl"] }
 serde_json = { version = "1.0.53", default-features = false, features = ["alloc"] }
+base64 = "0.10.1"
+parking_lot = "0.10"
 
 [lib]
 name="connector"
-crate-type=["staticlib","cdylib"]
+crate-type=["staticlib","cdylib"]
+#
+#[target.aarch64-linux-android.dependencies]
+#openssl = { version = "*", features = ["vendored"] }
+#[target.armv7-linux-androideabi.dependencies]
+#openssl = { version = "*", features = ["vendored"] }
+#[target.i686-linux-android.dependencies]
+#openssl = { version = "*", features = ["vendored"] }
+#[target.x86_64-linux-android.dependencies]
+#openssl = { version = "*", features = ["vendored"] }

api/src/api.rs

@@ -24,3 +24,113 @@ pub struct CommonResponse {
     #[prost(string, tag = "1")]
     pub result: std::string::String,
 }
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AddressParam {
+    #[prost(string, tag = "1")]
+    pub chain_type: std::string::String,
+    #[prost(string, tag = "2")]
+    pub path: std::string::String,
+    #[prost(string, tag = "3")]
+    pub network: std::string::String,
+    #[prost(bool, tag = "4")]
+    pub is_seg_wit: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AddressResult {
+    #[prost(string, tag = "1")]
+    pub path: std::string::String,
+    #[prost(string, tag = "2")]
+    pub chain_type: std::string::String,
+    #[prost(string, tag = "3")]
+    pub address: std::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PubKeyParam {
+    #[prost(string, tag = "1")]
+    pub chain_type: std::string::String,
+    #[prost(string, tag = "2")]
+    pub path: std::string::String,
+    #[prost(string, tag = "3")]
+    pub network: std::string::String,
+    #[prost(string, tag = "4")]
+    pub is_seg_wit: std::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PubKeyResult {
+    #[prost(string, tag = "1")]
+    pub path: std::string::String,
+    #[prost(string, tag = "2")]
+    pub chain_type: std::string::String,
+    #[prost(string, tag = "3")]
+    pub pub_key: std::string::String,
+    #[prost(string, tag = "4")]
+    pub derived_mode: std::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ExternalAddress {
+    #[prost(string, tag = "1")]
+    pub address: std::string::String,
+    #[prost(string, tag = "2")]
+    pub derived_path: std::string::String,
+    #[prost(string, tag = "3")]
+    pub r#type: std::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct BitcoinWallet {
+    #[prost(string, tag = "1")]
+    pub path: std::string::String,
+    #[prost(string, tag = "2")]
+    pub chain_type: std::string::String,
+    #[prost(string, tag = "3")]
+    pub address: std::string::String,
+    #[prost(string, tag = "4")]
+    pub enc_x_pub: std::string::String,
+    #[prost(message, optional, tag = "5")]
+    pub external_address: ::std::option::Option<ExternalAddress>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct EosWallet {
+    #[prost(string, tag = "1")]
+    pub chain_type: std::string::String,
+    #[prost(string, tag = "2")]
+    pub address: std::string::String,
+    #[prost(message, repeated, tag = "3")]
+    pub public_keys: ::std::vec::Vec<eos_wallet::PubKeyInfo>,
+}
+pub mod eos_wallet {
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct PubKeyInfo {
+        #[prost(string, tag = "1")]
+        pub path: std::string::String,
+        #[prost(string, tag = "2")]
+        pub derived_mode: std::string::String,
+        #[prost(string, tag = "3")]
+        pub public_key: std::string::String,
+    }
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ExternalAddressParam {
+    #[prost(string, tag = "1")]
+    pub path: std::string::String,
+    #[prost(string, tag = "2")]
+    pub chain_type: std::string::String,
+    #[prost(string, tag = "3")]
+    pub network: std::string::String,
+    #[prost(string, tag = "4")]
+    pub seg_wit: std::string::String,
+    #[prost(int32, tag = "5")]
+    pub external_idx: i32,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InitImKeyCoreXParam {
+    #[prost(string, tag = "1")]
+    pub file_dir: std::string::String,
+    #[prost(string, tag = "2")]
+    pub xpub_common_key: std::string::String,
+    #[prost(string, tag = "3")]
+    pub xpub_common_iv: std::string::String,
+    #[prost(bool, tag = "4")]
+    pub is_debug: bool,
+    #[prost(string, tag = "5")]
+    pub system: std::string::String,
+}

api/src/btc_address.rs

@@ -1,8 +1,11 @@
+use crate::api::{
+    AddressParam, AddressResult, BitcoinWallet, ExternalAddress, ExternalAddressParam,
+};
 use crate::error_handling::Result;
 use crate::message_handler::encode_message;
 use bitcoin::Network;
 use coin_bitcoin::address::BtcAddress;
-use coin_bitcoin::btcapi::{BtcAddressReq, BtcAddressRes, BtcXpubReq, BtcXpubRes};
+use coin_bitcoin::btcapi::{BtcXpubReq, BtcXpubRes};
 use prost::Message;
 
 pub fn get_btc_xpub(data: &[u8]) -> Result<Vec<u8>> {
@@ -20,61 +23,122 @@ pub fn get_btc_xpub(data: &[u8]) -> Result<Vec<u8>> {
     encode_message(address_message)
 }
 
-pub fn get_btc_address(data: &[u8]) -> Result<Vec<u8>> {
-    let input: BtcAddressReq = BtcAddressReq::decode(data).expect("imkey_illegal_param");
-
-    let network = match input.network.as_ref() {
+pub fn get_address(param: &AddressParam) -> Result<Vec<u8>> {
+    let network = match param.network.as_ref() {
         "MAINNET" => Network::Bitcoin,
         "TESTNET" => Network::Testnet,
         _ => Network::Testnet,
     };
 
-    let address = BtcAddress::get_address(network, input.path.as_ref())?;
+    let account_path = param.path.to_string();
+    let main_address: String;
+    let receive_address: String;
+
+    if param.is_seg_wit {
+        main_address =
+            BtcAddress::get_segwit_address(network, format!("{}/0/0", account_path).as_str())?;
+        receive_address =
+            BtcAddress::get_segwit_address(network, format!("{}/0/1", account_path).as_str())?;
+    } else {
+        main_address = BtcAddress::get_address(network, format!("{}/0/0", account_path).as_str())?;
+        receive_address =
+            BtcAddress::get_address(network, format!("{}/0/1", account_path).as_str())?;
+    }
+
+    let enc_xpub = get_enc_xpub(network, param.path.as_ref())?;
+
+    let external_address = ExternalAddress {
+        address: receive_address,
+        derived_path: "0/1".to_string(),
+        r#type: "EXTERNAL".to_string(),
+    };
 
-    let address_message = BtcAddressRes { address };
+    let address_message = BitcoinWallet {
+        path: param.path.to_owned(),
+        chain_type: param.chain_type.to_string(),
+        address: main_address,
+        enc_x_pub: enc_xpub,
+        external_address: Some(external_address),
+    };
     encode_message(address_message)
 }
 
-pub fn get_segwit_address(data: &[u8]) -> Result<Vec<u8>> {
-    let input: BtcAddressReq = BtcAddressReq::decode(data).expect("imkey_illegal_param");
-
-    let network = match input.network.as_ref() {
+pub fn calc_external_address(param: &ExternalAddressParam) -> Result<Vec<u8>> {
+    let network = match param.network.as_ref() {
         "MAINNET" => Network::Bitcoin,
         "TESTNET" => Network::Testnet,
         _ => Network::Testnet,
     };
 
-    let address = BtcAddress::get_segwit_address(network, input.path.as_ref())?;
+    let account_path = param.path.to_string();
+    let external_path = format!("{}/0/{}", account_path, param.external_idx);
+    let receive_address: String;
 
-    let address_message = BtcAddressRes { address };
-    encode_message(address_message)
+    if param.seg_wit.to_uppercase() == "P2WPKH" {
+        receive_address = BtcAddress::get_segwit_address(network, external_path.as_str())?;
+    } else {
+        receive_address = BtcAddress::get_address(network, external_path.as_str())?;
+    }
+
+    let external_address = ExternalAddress {
+        address: receive_address,
+        derived_path: format!("0/{}", param.external_idx),
+        r#type: "EXTERNAL".to_string(),
+    };
+
+    encode_message(external_address)
 }
 
-pub fn display_btc_address(data: &[u8]) -> Result<Vec<u8>> {
-    let input: BtcAddressReq = BtcAddressReq::decode(data).expect("imkey_illegal_param");
+pub fn get_enc_xpub(network: Network, path: &str) -> Result<String> {
+    let xpub = BtcAddress::get_xpub(network, path)?;
+    let key = common::XPUB_COMMON_KEY_128.read();
+    let iv = common::XPUB_COMMON_IV.read();
+    let key_bytes = hex::decode(&*key)?;
+    let iv_bytes = hex::decode(&*iv)?;
+    let encrypted = common::aes::cbc::encrypt_pkcs7(&xpub.as_bytes(), &key_bytes, &iv_bytes)?;
+    Ok(base64::encode(&encrypted))
+}
 
-    let network = match input.network.as_ref() {
+pub fn register_btc_address(param: &AddressParam) -> Result<Vec<u8>> {
+    if param.is_seg_wit {
+        display_segwit_address(param)
+    } else {
+        display_btc_legacy_address(param)
+    }
+}
+
+pub fn display_btc_legacy_address(param: &AddressParam) -> Result<Vec<u8>> {
+    let network = match param.network.as_ref() {
         "MAINNET" => Network::Bitcoin,
         "TESTNET" => Network::Testnet,
         _ => Network::Testnet,
     };
 
-    let address = BtcAddress::display_address(network, input.path.as_ref())?;
+    let path = format!("{}/0/0", param.path);
+    let address = BtcAddress::display_address(network, &path)?;
 
-    let address_message = BtcAddressRes { address };
+    let address_message = AddressResult {
+        address,
+        path: param.path.to_string(),
+        chain_type: param.chain_type.to_string(),
+    };
     encode_message(address_message)
 }
 
-pub fn display_segwit_address(data: &[u8]) -> Result<Vec<u8>> {
-    let input: BtcAddressReq = BtcAddressReq::decode(data).expect("imkey_illegal_param");
-    let network = match input.network.as_ref() {
+pub fn display_segwit_address(param: &AddressParam) -> Result<Vec<u8>> {
+    let network = match param.network.as_ref() {
         "MAINNET" => Network::Bitcoin,
         "TESTNET" => Network::Testnet,
         _ => Network::Testnet,
     };
 
-    let address = BtcAddress::display_segwit_address(network, input.path.as_ref())?;
+    let path = format!("{}/0/0", param.path);
+    let address = BtcAddress::display_segwit_address(network, &path)?;
 
-    let address_message = BtcAddressRes { address };
+    let address_message = AddressResult {
+        path: param.path.to_string(),
+        chain_type: param.chain_type.to_string(),
+        address,
+    };
     encode_message(address_message)
 }