Feature/polkadot

Cargo.toml

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

api/Cargo.toml

@@ -17,6 +17,7 @@ coin-bitcoin = {path = "../wallet/coin-bitcoin"}
 coin-eos = {path = "../wallet/coin-eos"}
 coin-cosmos = {path = "../wallet/coin-cosmos"}
 coin-filecoin = {path = "../wallet/coin-filecoin"}
+coin-substrate = {path = "../wallet/coin-substrate"}
 common = {path = "../common"}
 bitcoin = "0.25.0"
 ethereum-types = "0.6.0"

api/src/lib.rs

@@ -17,6 +17,8 @@ pub mod ethereum_signer;
 pub mod filecoin_address;
 pub mod filecoin_signer;
 pub mod message_handler;
+pub mod substrate_address;
+pub mod substrate_signer;
 use std::sync::Mutex;
 
 #[macro_use]
@@ -119,6 +121,8 @@ pub unsafe extern "C" fn call_imkey_api(hex_str: *const c_char) -> *const c_char
                 "ETHEREUM" => ethereum_address::get_address(&param),
                 "COSMOS" => cosmos_address::get_address(&param),
                 "FILECOIN" => filecoin_address::get_address(&param),
+                "POLKADOT" => substrate_address::get_address(&param),
+                "KUSAMA" => substrate_address::get_address(&param),
                 _ => Err(format_err!("get_address unsupported_chain")),
             }
         }),
@@ -149,6 +153,8 @@ pub unsafe extern "C" fn call_imkey_api(hex_str: *const c_char) -> *const c_char
                 "ETHEREUM" => ethereum_address::register_address(&param),
                 "COSMOS" => cosmos_address::display_cosmos_address(&param),
                 "FILECOIN" => filecoin_address::display_filecoin_address(&param),
+                "POLKADOT" => substrate_address::display_address(&param),
+                "KUSAMA" => substrate_address::display_address(&param),
                 _ => Err(format_err!("register_address unsupported_chain")),
             }
         }),
@@ -175,6 +181,12 @@ pub unsafe extern "C" fn call_imkey_api(hex_str: *const c_char) -> *const c_char
                     &param.clone().input.unwrap().value,
                     &param,
                 ),
+                "POLKADOT" => {
+                    substrate_signer::sign_transaction(&param.clone().input.unwrap().value, &param)
+                }
+                "KUSAMA" => {
+                    substrate_signer::sign_transaction(&param.clone().input.unwrap().value, &param)
+                }
                 _ => Err(format_err!("sign_tx unsupported_chain")),
             }
         }),

api/src/substrate_address.rs

@@ -0,0 +1,37 @@
+use crate::api::{AddressParam, AddressResult};
+use crate::error_handling::Result;
+use crate::message_handler::encode_message;
+use coin_substrate::address::{AddressType, SubstrateAddress};
+use prost::Message;
+
+pub fn get_address(param: &AddressParam) -> Result<Vec<u8>> {
+    let address_type = match param.chain_type.as_str() {
+        "POLKADOT" => AddressType::Polkadot,
+        "KUSAMA" => AddressType::Kusama,
+        _ => panic!("address type not support"),
+    };
+    let address = SubstrateAddress::get_address(param.path.as_ref(), &address_type)?;
+
+    let address_message = AddressResult {
+        path: param.path.to_owned(),
+        chain_type: param.chain_type.to_string(),
+        address,
+    };
+    encode_message(address_message)
+}
+
+pub fn display_address(param: &AddressParam) -> Result<Vec<u8>> {
+    let address_type = match param.chain_type.as_str() {
+        "POLKADOT" => AddressType::Polkadot,
+        "KUSAMA" => AddressType::Kusama,
+        _ => panic!("address type not support"),
+    };
+    let address = SubstrateAddress::display_address(param.path.as_ref(), &address_type)?;
+
+    let address_message = AddressResult {
+        path: param.path.to_owned(),
+        chain_type: param.chain_type.to_string(),
+        address,
+    };
+    encode_message(address_message)
+}

api/src/substrate_signer.rs

@@ -0,0 +1,12 @@
+use crate::error_handling::Result;
+use crate::message_handler::encode_message;
+use coin_substrate::substrateapi::SubstrateRawTxIn;
+use coin_substrate::transaction::Transaction;
+use common::SignParam;
+use prost::Message;
+
+pub fn sign_transaction(data: &[u8], sign_param: &SignParam) -> Result<Vec<u8>> {
+    let input: SubstrateRawTxIn = SubstrateRawTxIn::decode(data).unwrap();
+    let signed = Transaction::sign_transaction(&input, sign_param)?;
+    encode_message(signed)
+}