fix(sube): add working version

libwallet/js/Cargo.toml

@@ -15,7 +15,7 @@ js-sys = "0.3.61"
 rand_core = { version = "0.6.3", features = ["getrandom"] }
 serde = { version = "1.0.152", features = ["derive"] }
 serde-wasm-bindgen = "0.4.5"
-wasm-bindgen = "0.2.84"
+wasm-bindgen = "=0.2.84"
 wasm-bindgen-futures = "0.4.34"
 
 [dev-dependencies]

libwallet/src/key_pair.rs

@@ -1,4 +1,6 @@
-use core::fmt::Debug;
+
+
+use core::{fmt::Debug, convert::TryFrom};
 
 pub use derive::Derive;
 
@@ -21,7 +23,7 @@ impl<const N: usize> Public for Bytes<N> {}
 pub trait Signature: AsRef<[u8]> + Debug + PartialEq {}
 impl<const N: usize> Signature for Bytes<N> {}
 
-/// Something that can sign messages
+/// Something that can sign messagess
 pub trait Signer {
     type Signature: Signature;
     fn sign_msg<M: AsRef<[u8]>>(&self, msg: M) -> Self::Signature;

libwallet/src/lib.rs

@@ -1,4 +1,5 @@
 #![feature(async_fn_in_trait, impl_trait_projections)]
+#![feature(trait_alias)]
 // #![feature(result_option_inspect)]
 #![cfg_attr(not(feature = "std"), no_std)]
 //! `libwallet` is the one-stop tool to build easy, slightly opinionated crypto wallets

sube/Cargo.toml

@@ -12,15 +12,15 @@ log = "0.4.17"
 async-trait = "0.1.53"
 blake2 = { version = "0.10.5", default-features = false }
 codec = { version = "3.1.2", package = "parity-scale-codec", default-features = false }
-frame-metadata = { version = "15.0.0", git = "https://github.com/paritytech/frame-metadata.git", default-features = false, features = ["serde_full", "decode"] }
+frame-metadata = { version = "16.0.0", default-features = false, features = ["serde_full", "decode"] }
 hex = { version = "0.4.3", default-features = false, features = ["alloc"] }
 twox-hash = { version = "1.6.2", default-features = false }
 serde = { version = "1.0.137", default-features = false }
 async-once-cell = "0.4.4"
 
 scale-info = { version = "2.1.1", default-features = false, optional = true }
 jsonrpc = { version = "0.12.1", default-features = false, optional = true }
-scales = { path = "../scales", package = "scale-serialization", default-features = false, features = ["codec", "experimental-serializer"] }
+scales = { git = "https://github.com/virto-network/scales.git", package = "scale-serialization", default-features = false, features = ["codec", "experimental-serializer"] }
 
 # http backend
 surf = { version = "2.3.2", default_features = false, optional = true }
@@ -36,29 +36,35 @@ async-tls = { version = "0.11.0", default-features = false, optional = true }
 async-std = { version = "1.11.0", default_features = false, optional = true }
 serde_json = { version = "1.0.80", default-features = false, optional = true }
 url = { version = "2.2.2", optional = true }
-
-wasm-bindgen = "0.2.63"
-
+paste = { version = "1.0", optional = true }
+wasm-bindgen = { version = "=0.2.84", optional = true }
+once_cell = { version = "1.17.1", optional = true }
+heapless = { version = "0.7.16", optional = true }
+anyhow = { version = "1.0.40", optional = true }
+rand_core = {version = "0.6.3", optional = true }
 [dev-dependencies]
 async-std = { version = "1.11.0", features = ["attributes"] }
 hex-literal = "0.3.4"
+libwallet = { path = "../libwallet" }
 
 [features]
 # default = ["json", "std"]
-default = ["async-std", "builder", "v14", "url", "wss", "ws", "http", "json"]
+default = ["async-std", "builder", "url", "wss", "ws", "http", "json", "v14", "serde_json"]
 #default = ["v14", "ws", "decode", "json", "std"]
 # decode = ["v14", "serde", "scales/codec"]
 # encode = ["v14", ]
 http = ["jsonrpc", "surf/h1-client-rustls"]
-http-web = ["jsonrpc", "surf/wasm-client"]
-json = ["v14", "scales/json"]
+http-web = ["jsonrpc", "surf/wasm-client", "wasm-bindgen", "url", "serde_json"]
+json = [ "scales/json"]
 std = []
-builder = []
-v12 = ["frame-metadata/v12"]
-v13 = ["frame-metadata/v13"]
-v14 = ["frame-metadata/v14", "scale-info"]
+
+builder = ["paste", "once_cell", "heapless"]
+# v12 = ["frame-metadata/v12"]
+# v13 = ["frame-metadata/v13"]
+v14 = ["scale-info", "frame-metadata/current"]
 ws = ["async-std", "async-tungstenite", "async-mutex", "futures-util", "futures-channel", "jsonrpc"]
 wss = ["ws", "async-tls", "async-tungstenite/async-tls"]
+examples = ["anyhow", "rand_core"]
 
 
 [package.metadata.docs.rs]

sube/cli/Cargo.toml

@@ -19,7 +19,6 @@ hex = { version = "0.4.3", default-features = false, features = ["alloc"] }
 path = ".."
 features = [
   "std",
-  "v14", 
   "http",
   # "wss", 
 ]

sube/examples/query_balance.rs

@@ -1,10 +1,12 @@
-
-
-
-use sube::{ builder::SubeBuilder as Sube };
 use async_trait::async_trait;
+use core::future::{Future, IntoFuture};
+use sube::{ Response, sube, Result };
 
 #[async_std::main]
-async fn main () {
-    let a = Sube("wss://rpc.polkadot.io").await?;
+async fn main() -> Result<()> {
+
+    let result = sube!("https://kusama.olanod.com/system/_constants/version").await?;
+
+    println!("{:?}", result);
+    Ok(())
 }

sube/examples/query_balance_builder.rs

@@ -0,0 +1,13 @@
+use async_trait::async_trait;
+
+use sube::{ Response, sube, Result, builder::QueryBuilder, SignerFn, ExtrinicBody };
+
+#[async_std::main]
+async fn main() -> Result<()> {
+    let builder = QueryBuilder::default()
+        .with_url("https://kusama.olanod.com/system/_constants/version")
+        .await?;
+
+    println!("{:?}", builder);
+    Ok(())
+}

sube/examples/send_tx.rs

@@ -0,0 +1,47 @@
+use futures_util::TryFutureExt;
+use serde_json::json;
+use libwallet::{self, vault};
+use sube::sube;
+use std::env;
+use rand_core::OsRng;
+
+type Wallet = libwallet::Wallet<vault::Simple>;
+
+use anyhow::{ Result, anyhow };
+
+#[async_std::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let phrase = env::args().skip(1).collect::<Vec<_>>().join(" ");
+
+    let (vault, phrase) = if phrase.is_empty() {
+        vault::Simple::generate_with_phrase(&mut rand_core::OsRng)
+    } else {
+        let phrase: libwallet::Mnemonic = phrase.parse().expect("Invalid phrase");
+        (vault::Simple::from_phrase(&phrase), phrase)
+    };
+
+    let mut wallet = Wallet::new(vault);
+    wallet.unlock(None).await?;
+
+    let account = wallet.default_account();
+    let public = account.public();
+
+    let response = sube!("https://kusama.olanod.com/balances/transfer" => {
+        signer: |message: &[u8]| Ok(wallet.sign(message).into()),
+        sender: public.as_ref(),
+        body:  json!({
+            "dest": {
+                "Id": public.as_ref()
+            },
+            "value": 100000
+        }),
+    })
+    .map_err(|err| anyhow!(format!("SubeError {:?}", err)))
+    .await?;
+
+
+    println!("Secret phrase: \"{phrase}\"");
+    println!("Default Account: 0x{account}");
+
+    Ok(())
+}

sube/examples/send_tx_builder.rs

@@ -0,0 +1,49 @@
+use jsonrpc::error;
+use serde_json::json;
+use libwallet::{self, vault};
+use sube::builder::TxBuilder;
+use std::env;
+use rand_core::OsRng;
+
+type Wallet = libwallet::Wallet<vault::Simple>;
+use anyhow::{ Result, anyhow };
+
+#[async_std::main]
+async fn main() -> Result<()> {
+    let phrase = env::args().skip(1).collect::<Vec<_>>().join(" ");
+
+    let (vault, phrase) = if phrase.is_empty() {
+        vault::Simple::generate_with_phrase(&mut rand_core::OsRng)
+    } else {
+        let phrase: libwallet::Mnemonic = phrase.parse().expect("Invalid phrase");
+        (vault::Simple::from_phrase(&phrase), phrase)
+    };
+
+    let mut wallet = Wallet::new(vault);
+
+    wallet.unlock(None).await?;
+
+    let account = wallet.default_account();
+
+    let response = TxBuilder::default()
+        .with_url("https://kusama.olanod.com/balances/transfer")
+        .with_signer(|message: &[u8]| {
+            let signature = wallet.sign(message);
+            let signature: [u8; 64] = signature.as_ref()[..].try_into().expect("isn't a 64 size slice");
+            Ok(signature)
+        }
+        )
+        .with_sender(wallet.default_account().public().as_ref())
+        .with_body(json!({
+            "dest": {
+                "Id": wallet.default_account().public().as_ref()
+            },
+            "value": 100000
+        }))
+        .await
+        .map_err(|err| {
+            anyhow!(format!("Error {:?}", err))
+        })?;
+
+    Ok(())
+}

sube/examples/send_tx_signer.rs

@@ -0,0 +1,47 @@
+use futures_util::TryFutureExt;
+use serde_json::json;
+use libwallet::{self, vault};
+use sube::{ sube };
+use std::env;
+use rand_core::OsRng;
+
+type Wallet = libwallet::Wallet<vault::Simple>;
+
+use anyhow::{ Result, anyhow };
+
+#[async_std::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let phrase = env::args().skip(1).collect::<Vec<_>>().join(" ");
+
+    let (vault, phrase) = if phrase.is_empty() {
+        vault::Simple::generate_with_phrase(&mut rand_core::OsRng)
+    } else {
+        let phrase: libwallet::Mnemonic = phrase.parse().expect("Invalid phrase");
+        (vault::Simple::from_phrase(&phrase), phrase)
+    };
+
+    let mut wallet = Wallet::new(vault);
+    wallet.unlock(None).await?;
+
+    let account = wallet.default_account();
+    let public = account.public();
+
+
+    let response = sube!(
+        "https://kusama.olanod.com/balances/transfer" => 
+        (wallet, json!({
+            "dest": {
+                "Id": public.as_ref(),   
+            },
+            "value": 100000
+        }))
+    )
+    .map_err(|err| anyhow!(format!("SubeError {:?}", err)))
+    .await?;
+
+
+    println!("Secret phrase: \"{phrase}\"");
+    // println!("Default Account: 0x{account}");
+
+    Ok(())
+}

sube/examples/test.rs

@@ -0,0 +1,72 @@
+#![feature(prelude_import)]
+#[prelude_import]
+use std::prelude::rust_2021::*;
+#[macro_use]
+extern crate std;
+use futures_util::TryFutureExt;
+use serde_json::json;
+use libwallet::{self, vault};
+use sube::sube;
+use std::env;
+use rand_core::OsRng;
+type Wallet = libwallet::Wallet<vault::Simple>;
+use anyhow::{Result, anyhow};
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    async fn main() -> Result<(), Box<dyn std::error::Error>> {
+        {
+            let phrase = env::args().skip(1).collect::<Vec<_>>().join(" ");
+            let (vault, phrase) = if phrase.is_empty() {
+                vault::Simple::generate_with_phrase(&mut rand_core::OsRng)
+            } else {
+                let phrase: libwallet::Mnemonic = phrase
+                    .parse()
+                    .expect("Invalid phrase");
+                (vault::Simple::from_phrase(&phrase), phrase)
+            };
+            let mut wallet = Wallet::new(vault);
+            wallet.unlock(None).await?;
+            let account = wallet.default_account().public();
+            let public = account.as_ref();
+
+            let response = async {
+                let mut builder = ::sube::builder::TxBuilder::default();
+                // let account = &wallet.default_account();
+                // let public = account.public();
+
+                builder
+                    .with_signer(|message: &[u8]| Ok(wallet.sign(message).into()))
+                    .with_sender(public.into())
+                    .with_body(
+                        ::serde_json::Value::Object({
+                            let mut object = ::serde_json::Map::new();
+                            let _ = object
+                                .insert(
+                                    ("dest").into(),
+                                    ::serde_json::Value::Object({
+                                        let mut object = ::serde_json::Map::new();
+                                        let _ = object
+                                            .insert(
+                                                ("Id").into(),
+                                                ::serde_json::to_value(&public.as_ref()).unwrap(),
+                                            );
+                                        object
+                                    }),
+                                );
+                            let _ = object
+                                .insert(
+                                    ("value").into(),
+                                    ::serde_json::to_value(&100000).unwrap(),
+                                );
+                            object
+                        }),
+                    )
+                    .await
+            }
+                .map_err(|err| anyhow!(format!("SubeError {:?}", err)))
+                .await?;
+
+            Ok(())
+        }
+    }
+    async_std::task::block_on(async { main().await })
+}