saito-wasm 0.0.2

package/src/wasm_block.rs

@@ -0,0 +1,97 @@
+use js_sys::{Array, JsString, Uint8Array};
+use num_traits::FromPrimitive;
+use saito_core::common::defs::Timestamp;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+use saito_core::core::data::block::{Block, BlockType};
+
+use crate::saitowasm::string_to_key;
+use crate::wasm_transaction::WasmTransaction;
+
+#[wasm_bindgen]
+pub struct WasmBlock {
+    block: Block,
+}
+
+#[wasm_bindgen]
+impl WasmBlock {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WasmBlock {
+        WasmBlock {
+            block: Block::new(),
+        }
+    }
+    #[wasm_bindgen(getter = transactions)]
+    pub fn get_transactions(&self) -> Array {
+        let mut txs: Vec<WasmTransaction> = self
+            .block
+            .transactions
+            .iter()
+            .map(|tx| WasmTransaction::from_transaction(tx.clone()))
+            .collect();
+        let array = js_sys::Array::new_with_length(txs.len() as u32);
+        for (i, tx) in txs.drain(..).enumerate() {
+            array.set(i as u32, JsValue::from(tx));
+        }
+        array
+    }
+    #[wasm_bindgen(getter = id)]
+    pub fn get_id(&self) -> u64 {
+        self.block.id
+    }
+    #[wasm_bindgen(setter = id)]
+    pub fn set_id(&mut self, id: u64) {
+        self.block.id = id;
+    }
+    #[wasm_bindgen(getter = timestamp)]
+    pub fn get_timestamp(&self) -> Timestamp {
+        self.block.timestamp
+    }
+    #[wasm_bindgen(setter = timestamp)]
+    pub fn set_timestamp(&mut self, timestamp: Timestamp) {
+        self.block.timestamp = timestamp;
+    }
+    #[wasm_bindgen(getter = previous_block_hash)]
+    pub fn get_previous_block_hash(&self) -> JsString {
+        hex::encode(self.block.previous_block_hash).into()
+    }
+    #[wasm_bindgen(setter = previous_block_hash)]
+    pub fn set_previous_block_hash(&mut self, hash: JsString) {
+        self.block.previous_block_hash = string_to_key(hash).unwrap();
+    }
+    #[wasm_bindgen(setter = creator)]
+    pub fn set_creator(&mut self, key: JsString) {
+        self.block.creator = string_to_key(key).unwrap();
+    }
+    #[wasm_bindgen(getter = creator)]
+    pub fn get_creator(&self) -> JsString {
+        hex::encode(self.block.creator).into()
+    }
+    #[wasm_bindgen(getter = type)]
+    pub fn get_type(&self) -> u8 {
+        self.block.block_type as u8
+    }
+    #[wasm_bindgen(setter = type)]
+    pub fn set_type(&mut self, t: u8) {
+        self.block.block_type = BlockType::from_u8(t).unwrap();
+    }
+    #[wasm_bindgen(getter = hash)]
+    pub fn get_hash(&self) -> JsString {
+        hex::encode(self.block.hash).into()
+    }
+
+    #[wasm_bindgen]
+    pub fn serialize(&self) -> Uint8Array {
+        let buffer = self.block.serialize_for_net(BlockType::Full);
+        let buf = Uint8Array::new_with_length(buffer.len() as u32);
+        buf.copy_from(buffer.as_slice());
+        buf
+    }
+}
+
+impl WasmBlock {
+    pub fn from_block(block: Block) -> WasmBlock {
+        WasmBlock { block }
+    }
+}

package/src/wasm_configuration.rs

@@ -0,0 +1,94 @@
+use std::io::{Error, ErrorKind};
+
+use figment::providers::{Format, Json};
+use figment::Figment;
+use log::{error, info};
+use serde::Deserialize;
+
+use saito_core::core::data::configuration::{Configuration, Endpoint, PeerConfig, Server};
+
+// #[wasm_bindgen]
+#[derive(Deserialize, Debug)]
+pub struct WasmConfiguration {
+    server: Option<Server>,
+    peers: Vec<PeerConfig>,
+    #[serde(skip)]
+    spv_mode: bool,
+    #[serde(skip)]
+    browser_mode: bool,
+}
+
+// #[wasm_bindgen]
+impl WasmConfiguration {
+    pub fn new() -> WasmConfiguration {
+        WasmConfiguration {
+            server: Option::Some(Server {
+                host: "127.0.0.1".to_string(),
+                port: 12100,
+                protocol: "http".to_string(),
+                endpoint: Endpoint {
+                    host: "127.0.0.1".to_string(),
+                    port: 12101,
+                    protocol: "http".to_string(),
+                },
+                verification_threads: 2,
+                channel_size: 1000,
+                stat_timer_in_ms: 10000,
+                reconnection_wait_time: 10000,
+                thread_sleep_time_in_ms: 10,
+                block_fetch_batch_size: 0,
+            }),
+            peers: vec![],
+            spv_mode: true,
+            browser_mode: true,
+        }
+    }
+    pub fn new_from_json(json: &str) -> Result<WasmConfiguration, std::io::Error> {
+        // info!("new from json : {:?}", json);
+        let configs = Figment::new()
+            .merge(Json::string(json))
+            .extract::<WasmConfiguration>();
+        if configs.is_err() {
+            error!(
+                "failed parsing json string to configs. {:?}",
+                configs.err().unwrap()
+            );
+            return Err(Error::from(ErrorKind::InvalidInput));
+        }
+        let configs = configs.unwrap();
+        Ok(configs)
+    }
+}
+
+impl Configuration for WasmConfiguration {
+    fn get_server_configs(&self) -> Option<&Server> {
+        return self.server.as_ref();
+    }
+
+    fn get_peer_configs(&self) -> &Vec<PeerConfig> {
+        return &self.peers;
+    }
+
+    fn get_block_fetch_url(&self) -> String {
+        let endpoint = &self.get_server_configs().unwrap().endpoint;
+        endpoint.protocol.to_string()
+            + "://"
+            + endpoint.host.as_str()
+            + ":"
+            + endpoint.port.to_string().as_str()
+            + "/block/"
+    }
+    fn is_spv_mode(&self) -> bool {
+        self.spv_mode
+    }
+
+    fn is_browser(&self) -> bool {
+        self.browser_mode
+    }
+
+    fn replace(&mut self, config: &dyn Configuration) {
+        self.server = config.get_server_configs().cloned();
+        self.peers = config.get_peer_configs().clone();
+        self.spv_mode = config.is_spv_mode();
+    }
+}

package/src/wasm_io_handler.rs

@@ -0,0 +1,258 @@
+use std::fmt::{Debug, Formatter};
+use std::io::{Error, ErrorKind};
+
+use async_trait::async_trait;
+use js_sys::{Array, BigInt, Boolean, Uint8Array};
+use log::{info, trace};
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+use saito_core::common::defs::{PeerIndex, SaitoHash};
+use saito_core::common::interface_io::{InterfaceEvent, InterfaceIO};
+use saito_core::core::data::configuration::PeerConfig;
+use saito_core::core::data::transaction::Transaction;
+
+pub struct WasmIoHandler {}
+
+#[async_trait]
+impl InterfaceIO for WasmIoHandler {
+    async fn send_message(&self, peer_index: u64, buffer: Vec<u8>) -> Result<(), Error> {
+        info!("WasmIoHandler::send_message : {:?}", peer_index);
+
+        let array = js_sys::Uint8Array::new_with_length(buffer.len() as u32);
+        array.copy_from(buffer.as_slice());
+
+        // let async_fn =
+        MsgHandler::send_message(js_sys::BigInt::from(peer_index), &array);
+        // let promise = js_sys::Promise::resolve(async_fn);
+        // let result = wasm_bindgen_futures::JsFuture::from(async_fn).await;
+        drop(array);
+
+        Ok(())
+    }
+
+    async fn send_message_to_all(
+        &self,
+        buffer: Vec<u8>,
+        peer_exceptions: Vec<u64>,
+    ) -> Result<(), Error> {
+        let array = js_sys::Uint8Array::new_with_length(buffer.len() as u32);
+        array.copy_from(buffer.as_slice());
+
+        let arr2 = js_sys::Array::new_with_length(peer_exceptions.len() as u32);
+
+        for (i, ex) in peer_exceptions.iter().enumerate() {
+            let int = js_sys::BigInt::from(*ex);
+            let int = JsValue::from(int);
+
+            arr2.set(i as u32, int);
+        }
+
+        MsgHandler::send_message_to_all(&array, &arr2);
+
+        drop(array);
+        drop(arr2);
+
+        Ok(())
+    }
+
+    async fn connect_to_peer(&mut self, peer: PeerConfig) -> Result<(), Error> {
+        trace!("connect_to_peer : {:?}", peer.host);
+
+        let json_string = serde_json::to_string(&peer).unwrap();
+        let json = js_sys::JSON::parse(&json_string).unwrap();
+        MsgHandler::connect_to_peer(json);
+
+        Ok(())
+    }
+
+    // async fn process_interface_event(&mut self, event: InterfaceEvent) -> Result<(), Error> {
+    //     todo!()
+    // }
+
+    async fn disconnect_from_peer(&mut self, peer_index: u64) -> Result<(), Error> {
+        MsgHandler::disconnect_from_peer(js_sys::BigInt::from(peer_index));
+        Ok(())
+    }
+
+    // fn set_write_result(
+    //     &mut self,
+    //     result_key: String,
+    //     result: Result<String, Error>,
+    // ) -> Result<(), Error> {
+    //     todo!()
+    // }
+
+    async fn fetch_block_from_peer(
+        &self,
+        block_hash: SaitoHash,
+        peer_index: u64,
+        url: String,
+    ) -> Result<(), Error> {
+        let hash = js_sys::Uint8Array::new_with_length(32);
+        hash.copy_from(block_hash.as_slice());
+        MsgHandler::fetch_block_from_peer(&hash, BigInt::from(peer_index), url);
+
+        drop(hash);
+
+        Ok(())
+    }
+
+    async fn write_value(&mut self, key: String, value: Vec<u8>) -> Result<(), Error> {
+        let array = js_sys::Uint8Array::new_with_length(value.len() as u32);
+        array.copy_from(value.as_slice());
+
+        MsgHandler::write_value(key, &array);
+        drop(array);
+
+        Ok(())
+    }
+
+    async fn read_value(&self, key: String) -> Result<Vec<u8>, Error> {
+        let result = MsgHandler::read_value(key);
+        if result.is_err() {
+            return Err(Error::from(ErrorKind::Other));
+        }
+
+        let result = result.unwrap();
+        let v = result.to_vec();
+        drop(result);
+        Ok(v)
+    }
+
+    async fn load_block_file_list(&self) -> Result<Vec<String>, Error> {
+        let result = MsgHandler::load_block_file_list();
+        if result.is_err() {
+            return Err(Error::from(ErrorKind::Other));
+        }
+
+        let result = result.unwrap();
+        let result = Array::try_from(result);
+        if result.is_err() {
+            return Err(Error::from(ErrorKind::Other));
+        }
+        let result = result.unwrap();
+
+        let mut v = vec![];
+        for i in 0..result.length() {
+            let res = result.get(i);
+            let res = js_sys::JsString::from(res).as_string().unwrap();
+            v.push(res);
+        }
+
+        Ok(v)
+    }
+
+    async fn is_existing_file(&self, key: String) -> bool {
+        let result = MsgHandler::is_existing_file(key);
+        if result.is_err() {
+            return false;
+        }
+
+        let result = result.unwrap();
+        result.into()
+    }
+
+    async fn remove_value(&self, key: String) -> Result<(), Error> {
+        MsgHandler::remove_value(key);
+
+        Ok(())
+    }
+
+    fn get_block_dir(&self) -> String {
+        "data/blocks/".to_string()
+    }
+
+    async fn process_api_call(&self, buffer: Vec<u8>, msg_index: u32, peer_index: PeerIndex) {
+        let buf = Uint8Array::new_with_length(buffer.len() as u32);
+        buf.copy_from(buffer.as_slice());
+        MsgHandler::process_api_call(buf, msg_index, peer_index);
+    }
+
+    async fn process_api_success(&self, buffer: Vec<u8>, msg_index: u32, peer_index: PeerIndex) {
+        // let tx = Transaction::deserialize_from_net(&buffer);
+        // let buffer = tx.data;
+        let buf = Uint8Array::new_with_length(buffer.len() as u32);
+        buf.copy_from(buffer.as_slice());
+        MsgHandler::process_api_success(buf, msg_index, peer_index);
+    }
+
+    async fn process_api_error(&self, buffer: Vec<u8>, msg_index: u32, peer_index: PeerIndex) {
+        // let tx = Transaction::deserialize_from_net(&buffer);
+        // let buffer = tx.data;
+
+        let buf = Uint8Array::new_with_length(buffer.len() as u32);
+        buf.copy_from(buffer.as_slice());
+        MsgHandler::process_api_error(buf, msg_index, peer_index);
+    }
+
+    fn send_interface_event(&self, event: InterfaceEvent) {
+        match event {
+            InterfaceEvent::PeerHandshakeComplete(index) => {
+                MsgHandler::send_interface_event("handshake_complete".to_string(), index);
+            }
+            InterfaceEvent::PeerConnectionDropped(index) => {
+                MsgHandler::send_interface_event("peer_disconnect".to_string(), index);
+            }
+            InterfaceEvent::PeerConnected(index) => {
+                MsgHandler::send_interface_event("peer_connect".to_string(), index);
+            }
+        }
+    }
+}
+
+impl Debug for WasmIoHandler {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RustIoHandler")
+            // .field("handler_id", &self.handler_id)
+            .finish()
+    }
+}
+
+#[wasm_bindgen(module = "/js/msg_handler.js")]
+extern "C" {
+    type MsgHandler;
+
+    #[wasm_bindgen(static_method_of = MsgHandler)]
+    pub fn send_message(peer_index: BigInt, buffer: &Uint8Array);
+
+    #[wasm_bindgen(static_method_of = MsgHandler)]
+    pub fn send_message_to_all(buffer: &Uint8Array, exceptions: &Array);
+
+    #[wasm_bindgen(static_method_of = MsgHandler, catch)]
+    pub fn connect_to_peer(peer_data: JsValue) -> Result<JsValue, js_sys::Error>;
+    #[wasm_bindgen(static_method_of = MsgHandler)]
+    pub fn write_value(key: String, value: &Uint8Array);
+
+    #[wasm_bindgen(static_method_of = MsgHandler, catch)]
+    pub fn read_value(key: String) -> Result<Uint8Array, js_sys::Error>;
+
+    #[wasm_bindgen(static_method_of = MsgHandler, catch)]
+    pub fn load_block_file_list() -> Result<Array, js_sys::Error>;
+    #[wasm_bindgen(static_method_of = MsgHandler, catch)]
+    pub fn is_existing_file(key: String) -> Result<Boolean, js_sys::Error>;
+    #[wasm_bindgen(static_method_of = MsgHandler, catch)]
+    pub fn remove_value(key: String) -> Result<JsValue, JsValue>;
+
+    #[wasm_bindgen(static_method_of = MsgHandler, catch)]
+    pub fn disconnect_from_peer(peer_index: BigInt) -> Result<JsValue, js_sys::Error>;
+
+    #[wasm_bindgen(static_method_of = MsgHandler, catch)]
+    pub fn fetch_block_from_peer(
+        hash: &Uint8Array,
+        peer_index: BigInt,
+        url: String,
+    ) -> Result<JsValue, js_sys::Error>;
+
+    #[wasm_bindgen(static_method_of = MsgHandler)]
+    pub fn process_api_call(buffer: Uint8Array, msg_index: u32, peer_index: u64);
+
+    #[wasm_bindgen(static_method_of = MsgHandler)]
+    pub fn process_api_success(buffer: Uint8Array, msg_index: u32, peer_index: u64);
+
+    #[wasm_bindgen(static_method_of = MsgHandler)]
+    pub fn process_api_error(buffer: Uint8Array, msg_index: u32, peer_index: u64);
+
+    #[wasm_bindgen(static_method_of = MsgHandler)]
+    pub fn send_interface_event(event: String, peer_index: u64);
+}

package/src/wasm_peer.rs

@@ -0,0 +1,80 @@
+use js_sys::{Array, JsString};
+use log::warn;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+use saito_core::common::defs::PeerIndex;
+use saito_core::core::data::peer::Peer;
+
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct WasmPeer {
+    peer: Peer,
+}
+
+#[wasm_bindgen]
+impl WasmPeer {
+    #[wasm_bindgen(getter = public_key)]
+    pub fn get_public_key(&self) -> JsString {
+        if self.peer.public_key.is_none() {
+            warn!("peer : {:?} public key is not set", self.peer.index);
+        }
+        hex::encode(self.peer.public_key.unwrap()).into()
+    }
+    #[wasm_bindgen(getter = key_list)]
+    pub fn get_key_list(&self) -> Array {
+        let array = Array::new_with_length(self.peer.key_list.len() as u32);
+        for (i, key) in self.peer.key_list.iter().enumerate() {
+            array.set(i as u32, JsValue::from(hex::encode(key)));
+        }
+        array
+    }
+
+    #[wasm_bindgen(getter = peer_index)]
+    pub fn get_peer_index(&self) -> u64 {
+        self.peer.index
+    }
+    #[wasm_bindgen(constructor)]
+    pub fn new(peer_index: PeerIndex) -> WasmPeer {
+        WasmPeer {
+            peer: Peer::new(peer_index),
+        }
+    }
+    #[wasm_bindgen(getter = sync_type)]
+    pub fn get_sync_type(&self) -> JsString {
+        if self.peer.block_fetch_url.is_empty() {
+            return "lite".into();
+        }
+        return "full".into();
+    }
+    #[wasm_bindgen(getter = services)]
+    pub fn get_services(&self) -> JsValue {
+        let arr = js_sys::Array::new_with_length(self.peer.services.len() as u32);
+        for (i, service) in self.peer.services.iter().enumerate() {
+            arr.set(i as u32, JsValue::from(JsString::from(service.as_str())));
+        }
+        JsValue::from(arr)
+    }
+    #[wasm_bindgen(setter = services)]
+    pub fn set_services(&mut self, services: JsValue) {
+        let services = js_sys::Array::from(&services);
+        let mut ser = vec![];
+        for i in 0..services.length() {
+            let str = JsString::from(services.at(i as i32));
+            ser.push(str.into());
+        }
+        self.peer.services = ser;
+    }
+    pub fn has_service(&self, service: JsString) -> bool {
+        return self.peer.has_service(service.into());
+    }
+    pub fn is_main_peer(&self) -> bool {
+        self.peer.is_main_peer()
+    }
+}
+
+impl WasmPeer {
+    pub fn new_from_peer(peer: Peer) -> WasmPeer {
+        WasmPeer { peer }
+    }
+}

package/src/wasm_slip.rs

@@ -0,0 +1,101 @@
+use js_sys::JsString;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+use num_traits::FromPrimitive;
+use saito_core::common::defs::{Currency, SaitoUTXOSetKey};
+use saito_core::core::data::slip::{Slip, SlipType};
+
+use crate::saitowasm::string_to_key;
+
+// #[derive(Serialize, Deserialize)]
+#[wasm_bindgen]
+pub struct WasmSlip {
+    pub(crate) slip: Slip,
+}
+
+#[wasm_bindgen]
+impl WasmSlip {
+    #[wasm_bindgen(getter=amount)]
+    pub fn amount(&self) -> u64 {
+        self.slip.amount
+    }
+    #[wasm_bindgen(setter=amount)]
+    pub fn set_amount(&mut self, amount: Currency) {
+        self.slip.amount = amount;
+    }
+    #[wasm_bindgen(getter=slip_type)]
+    pub fn slip_type(&self) -> u8 {
+        self.slip.slip_type as u8
+    }
+    #[wasm_bindgen(setter=slip_type)]
+    pub fn set_slip_type(&mut self, slip_type: u8) {
+        self.slip.slip_type = SlipType::from_u8(slip_type).expect("value is not in slip types");
+    }
+    #[wasm_bindgen(getter=public_key)]
+    pub fn public_key(&self) -> JsString {
+        let key = hex::encode(self.slip.public_key);
+        key.into()
+    }
+    #[wasm_bindgen(setter=public_key)]
+    pub fn set_public_key(&mut self, key: JsString) {
+        let key = string_to_key(key).unwrap();
+
+        self.slip.public_key = key;
+    }
+    #[wasm_bindgen(getter=slip_index)]
+    pub fn slip_index(&self) -> u8 {
+        self.slip.slip_index
+    }
+    #[wasm_bindgen(setter=slip_index)]
+    pub fn set_slip_index(&mut self, index: u8) {
+        self.slip.slip_index = index;
+    }
+    #[wasm_bindgen(getter=block_id)]
+    pub fn block_id(&self) -> u64 {
+        self.slip.block_id
+    }
+    #[wasm_bindgen(setter=block_id)]
+    pub fn set_block_id(&mut self, id: u64) {
+        self.slip.block_id = id;
+    }
+    #[wasm_bindgen(getter=tx_ordinal)]
+    pub fn tx_ordinal(&self) -> u64 {
+        self.slip.tx_ordinal
+    }
+    #[wasm_bindgen(setter=tx_ordinal)]
+    pub fn set_tx_ordinal(&mut self, ordinal: u64) {
+        self.slip.tx_ordinal = ordinal;
+    }
+    #[wasm_bindgen(setter=utxo_key)]
+    pub fn set_utxo_key(&mut self, key: JsString) {
+        let key: SaitoUTXOSetKey = string_to_key(key).unwrap();
+        self.slip.utxoset_key = key;
+    }
+    #[wasm_bindgen(getter=utxo_key)]
+    pub fn utxo_key(&self) -> JsString {
+        let key = hex::encode(self.slip.utxoset_key);
+        key.into()
+    }
+
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WasmSlip {
+        WasmSlip {
+            slip: Slip {
+                public_key: [0; 33],
+                amount: 0,
+                slip_index: 0,
+                block_id: 0,
+                tx_ordinal: 0,
+                slip_type: SlipType::Normal,
+                utxoset_key: [0; 58],
+                is_utxoset_key_set: false,
+            },
+        }
+    }
+}
+
+impl WasmSlip {
+    pub fn new_from_slip(slip: Slip) -> WasmSlip {
+        WasmSlip { slip }
+    }
+}

package/src/wasm_task_runner.rs

@@ -0,0 +1,12 @@
+use std::pin::Pin;
+
+use saito_core::common::run_task::RunTask;
+
+pub struct WasmTaskRunner {}
+
+impl RunTask for WasmTaskRunner {
+    fn run(&self, task: Pin<Box<dyn Fn() -> () + Send + 'static>>) {
+        println!("WasmTaskRunner.run");
+        task();
+    }
+}

package/src/wasm_time_keeper.rs

@@ -0,0 +1,12 @@
+use saito_core::common::defs::Timestamp;
+use saito_core::common::keep_time::KeepTime;
+
+pub struct WasmTimeKeeper {}
+
+impl KeepTime for WasmTimeKeeper {
+    fn get_timestamp_in_ms(&self) -> Timestamp {
+        let date = js_sys::Date::new_0();
+
+        date.get_time() as Timestamp
+    }
+}