Pskb Broadcast

cli/src/cli.rs

@@ -285,12 +285,14 @@ impl KaspaCli {
 
                         if let Ok(msg) = msg {
                             match *msg {
+                                Events::WalletList { .. } => {},
                                 Events::WalletPing => {
                                     // log_info!("Kaspa NG - received wallet ping");
                                 },
                                 Events::Metrics { network_id : _, metrics : _ } => {
                                     // log_info!("Kaspa NG - received metrics event {metrics:?}")
                                 }
+                                Events::FeeRate { .. } => {},
                                 Events::Error { message } => { terrorln!(this,"{message}"); },
                                 Events::UtxoProcStart => {},
                                 Events::UtxoProcStop => {},

cli/src/modules/account.rs

@@ -234,8 +234,9 @@ impl Account {
                 count = count.max(1);
 
                 let sweep = action.eq("sweep");
-
-                self.derivation_scan(&ctx, start, count, window, sweep).await?;
+                // TODO fee_rate
+                let fee_rate = None;
+                self.derivation_scan(&ctx, start, count, window, sweep, fee_rate).await?;
             }
             v => {
                 tprintln!(ctx, "unknown command: '{v}'\r\n");
@@ -276,6 +277,7 @@ impl Account {
         count: usize,
         window: usize,
         sweep: bool,
+        fee_rate: Option<f64>,
     ) -> Result<()> {
         let account = ctx.account().await?;
         let (wallet_secret, payment_secret) = ctx.ask_wallet_secret(Some(&account)).await?;
@@ -293,7 +295,9 @@ impl Account {
                 start + count,
                 window,
                 sweep,
+                fee_rate,
                 &abortable,
+                true,
                 Some(Arc::new(move |processed: usize, _, balance, txid| {
                     if let Some(txid) = txid {
                         tprintln!(

cli/src/modules/estimate.rs

@@ -17,13 +17,16 @@ impl Estimate {
         }
 
         let amount_sompi = try_parse_required_nonzero_kaspa_as_sompi_u64(argv.first())?;
+        // TODO fee_rate
+        let fee_rate = None;
         let priority_fee_sompi = try_parse_optional_kaspa_as_sompi_i64(argv.get(1))?.unwrap_or(0);
         let abortable = Abortable::default();
 
         // just use any address for an estimate (change address)
         let change_address = account.change_address()?;
         let destination = PaymentDestination::PaymentOutputs(PaymentOutputs::from((change_address.clone(), amount_sompi)));
-        let estimate = account.estimate(destination, priority_fee_sompi.into(), None, &abortable).await?;
+        // TODO fee_rate
+        let estimate = account.estimate(destination, fee_rate, priority_fee_sompi.into(), None, &abortable).await?;
 
         tprintln!(ctx, "Estimate - {estimate}");
 

cli/src/modules/pskb.rs

@@ -45,6 +45,8 @@ impl Pskb {
                 let signer = account
                     .pskb_from_send_generator(
                         outputs.into(),
+                        // fee_rate
+                        None,
                         priority_fee_sompi.into(),
                         None,
                         wallet_secret.clone(),
@@ -89,12 +91,15 @@ impl Pskb {
                     "lock" => {
                         let amount_sompi = try_parse_required_nonzero_kaspa_as_sompi_u64(argv.first())?;
                         let outputs = PaymentOutputs::from((script_p2sh, amount_sompi));
+                        // TODO fee_rate
+                        let fee_rate = None;
                         let priority_fee_sompi = try_parse_optional_kaspa_as_sompi_i64(argv.get(1))?.unwrap_or(0);
                         let abortable = Abortable::default();
 
                         let signer = account
                             .pskb_from_send_generator(
                                 outputs.into(),
+                                fee_rate,
                                 priority_fee_sompi.into(),
                                 None,
                                 wallet_secret.clone(),
@@ -209,13 +214,12 @@ impl Pskb {
                 for (pskt_index, bundle_inner) in pskb.0.iter().enumerate() {
                     tprintln!(ctx, "PSKT #{:03} finalized check:", pskt_index + 1);
                     let pskt: PSKT<Signer> = PSKT::<Signer>::from(bundle_inner.to_owned());
-
+                    let params = ctx.wallet().network_id()?.into();
                     let finalizer = pskt.finalizer();
-
                     if let Ok(pskt_finalizer) = finalize_pskt_one_or_more_sig_and_redeem_script(finalizer) {
                         // Verify if extraction is possible.
                         match pskt_finalizer.extractor() {
-                            Ok(ex) => match ex.extract_tx() {
+                            Ok(ex) => match ex.extract_tx(&params) {
                                 Ok(_) => tprintln!(
                                     ctx,
                                     "  Transaction extracted successfully: PSKT is finalized with a valid script signature."

cli/src/modules/send.rs

@@ -18,6 +18,8 @@ impl Send {
 
         let address = Address::try_from(argv.first().unwrap().as_str())?;
         let amount_sompi = try_parse_required_nonzero_kaspa_as_sompi_u64(argv.get(1))?;
+        // TODO fee_rate
+        let fee_rate = None;
         let priority_fee_sompi = try_parse_optional_kaspa_as_sompi_i64(argv.get(2))?.unwrap_or(0);
         let outputs = PaymentOutputs::from((address.clone(), amount_sompi));
         let abortable = Abortable::default();
@@ -27,6 +29,7 @@ impl Send {
         let (summary, _ids) = account
             .send(
                 outputs.into(),
+                fee_rate,
                 priority_fee_sompi.into(),
                 None,
                 wallet_secret,

cli/src/modules/sweep.rs

@@ -10,12 +10,15 @@ impl Sweep {
 
         let account = ctx.wallet().account()?;
         let (wallet_secret, payment_secret) = ctx.ask_wallet_secret(Some(&account)).await?;
+        // TODO fee_rate
+        let fee_rate = None;
         let abortable = Abortable::default();
         // let ctx_ = ctx.clone();
         let (summary, _ids) = account
             .sweep(
                 wallet_secret,
                 payment_secret,
+                fee_rate,
                 &abortable,
                 Some(Arc::new(move |_ptx| {
                     // tprintln!(ctx_, "Sending transaction: {}", ptx.id());

cli/src/modules/transfer.rs

@@ -21,6 +21,8 @@ impl Transfer {
             return Err("Cannot transfer to the same account".into());
         }
         let amount_sompi = try_parse_required_nonzero_kaspa_as_sompi_u64(argv.get(1))?;
+        // TODO fee_rate
+        let fee_rate = None;
         let priority_fee_sompi = try_parse_optional_kaspa_as_sompi_i64(argv.get(2))?.unwrap_or(0);
         let target_address = target_account.receive_address()?;
         let (wallet_secret, payment_secret) = ctx.ask_wallet_secret(Some(&account)).await?;
@@ -32,6 +34,7 @@ impl Transfer {
         let (summary, _ids) = account
             .send(
                 outputs.into(),
+                fee_rate,
                 priority_fee_sompi.into(),
                 None,
                 wallet_secret,

cli/src/wizards/account.rs

@@ -3,6 +3,7 @@ use crate::imports::*;
 use crate::result::Result;
 use kaspa_bip32::{Language, Mnemonic, WordCount};
 use kaspa_wallet_core::account::MULTISIG_ACCOUNT_KIND;
+use kaspa_wallet_core::storage::keydata::PrvKeyDataVariantKind;
 // use kaspa_wallet_core::runtime::wallet::AccountCreateArgsBip32;
 // use kaspa_wallet_core::runtime::{PrvKeyDataArgs, PrvKeyDataCreateArgs};
 // use kaspa_wallet_core::storage::AccountKind;
@@ -66,7 +67,7 @@ async fn create_multisig(ctx: &Arc<KaspaCli>, account_name: Option<String>, mnem
     for _ in 0..prv_keys_len {
         let bip39_mnemonic = Secret::from(Mnemonic::random(mnemonic_phrase_word_count, Language::default())?.phrase());
 
-        let prv_key_data_create_args = PrvKeyDataCreateArgs::new(None, None, bip39_mnemonic); // can be optimized with Rc<WalletSecret>
+        let prv_key_data_create_args = PrvKeyDataCreateArgs::new(None, None, bip39_mnemonic, PrvKeyDataVariantKind::Mnemonic); // can be optimized with Rc<WalletSecret>
         let prv_key_data_id = wallet.create_prv_key_data(&wallet_secret, prv_key_data_create_args).await?;
 
         prv_key_data_args.push(PrvKeyDataArgs::new(prv_key_data_id, None));

cli/src/wizards/wallet.rs

@@ -2,6 +2,7 @@ use crate::cli::KaspaCli;
 use crate::imports::*;
 use crate::result::Result;
 use kaspa_bip32::{Language, Mnemonic, WordCount};
+use kaspa_wallet_core::storage::keydata::PrvKeyDataVariantKind;
 use kaspa_wallet_core::{
     storage::{make_filename, Hint},
     wallet::WalletGuard,
@@ -123,16 +124,17 @@ pub(crate) async fn create(
 
     let prv_key_data_args = if import_with_mnemonic {
         let words = crate::wizards::import::prompt_for_mnemonic(&term).await?;
-        PrvKeyDataCreateArgs::new(None, payment_secret.clone(), Secret::from(words.join(" ")))
+        PrvKeyDataCreateArgs::new(None, payment_secret.clone(), Secret::from(words.join(" ")), PrvKeyDataVariantKind::Mnemonic)
     } else {
         PrvKeyDataCreateArgs::new(
             None,
             payment_secret.clone(),
             Secret::from(Mnemonic::random(word_count, Language::default())?.phrase()),
+            PrvKeyDataVariantKind::Mnemonic,
         )
     };
 
-    let mnemonic_phrase = prv_key_data_args.mnemonic.clone();
+    let mnemonic_phrase = prv_key_data_args.secret.clone();
 
     let notifier = ctx.notifier().show(Notification::Processing).await;
 

crypto/addresses/src/lib.rs

@@ -512,7 +512,7 @@ impl TryCastFromJs for Address {
     {
         Self::resolve(value, || {
             if let Some(string) = value.as_ref().as_string() {
-                Address::try_from(string)
+                Address::try_from(string.trim())
             } else if let Some(object) = js_sys::Object::try_from(value.as_ref()) {
                 let prefix: Prefix = object.get_string("prefix")?.as_str().try_into()?;
                 let payload = object.get_string("payload")?; //.as_str();

crypto/txscript/src/opcodes/macros.rs

@@ -139,7 +139,7 @@ macro_rules! opcode_list {
                     }
                 }
                 else if let Some(Ok(value)) = token.strip_prefix("0x").and_then(|trimmed| Some(hex::decode(trimmed))) {
-                    builder.extend(&value);
+                    builder.script_mut().extend(&value);
                 }
                 else if token.len() >= 2 && token.chars().nth(0) == Some('\'') && token.chars().last() == Some('\'') {
                     builder.add_data(token[1..token.len()-1].as_bytes())?;

crypto/txscript/src/script_builder.rs

@@ -74,11 +74,15 @@ impl ScriptBuilder {
         &self.script
     }
 
-    #[cfg(any(test, target_arch = "wasm32"))]
-    pub fn extend(&mut self, data: &[u8]) {
-        self.script.extend(data);
+    pub fn script_mut(&mut self) -> &mut Vec<u8> {
+        &mut self.script
     }
 
+    // #[cfg(any(test, target_arch = "wasm32"))]
+    // pub fn extend(&mut self, data: &[u8]) {
+    //     self.script.extend(data);
+    // }
+
     pub fn drain(&mut self) -> Vec<u8> {
         // Note that the internal script, when taken, is replaced by
         // vector with no predefined capacity because the script

crypto/txscript/src/wasm/builder.rs

@@ -53,7 +53,7 @@ impl ScriptBuilder {
     pub fn from_script(script: BinaryT) -> Result<ScriptBuilder> {
         let builder = ScriptBuilder::default();
         let script = script.try_as_vec_u8()?;
-        builder.inner_mut().extend(&script);
+        builder.inner_mut().script_mut().extend(&script);
 
         Ok(builder)
     }

rpc/wrpc/client/Cargo.toml

@@ -5,9 +5,16 @@ rust-version.workspace = true
 version.workspace = true
 edition.workspace = true
 authors.workspace = true
-include.workspace = true
 license.workspace = true
 repository.workspace = true
+include = [
+    "src/**/*.rs",
+    "benches/**/*.rs",
+    "build.rs",
+    "Cargo.toml",
+    "Cargo.lock",
+    "Resolvers.toml",
+]
 
 [features]
 wasm32-sdk = ["kaspa-consensus-wasm/wasm32-sdk","kaspa-rpc-core/wasm32-sdk","workflow-rpc/wasm32-sdk"]

rpc/wrpc/wasm/src/client.rs

@@ -351,8 +351,8 @@ impl RpcClient {
     /// Set the network id for the RPC client.
     /// This setting will take effect on the next connection.
     #[wasm_bindgen(js_name = setNetworkId)]
-    pub fn set_network_id(&self, network_id: &NetworkId) -> Result<()> {
-        self.inner.client.set_network_id(network_id)?;
+    pub fn set_network_id(&self, network_id: &NetworkIdT) -> Result<()> {
+        self.inner.client.set_network_id(&network_id.try_into_owned()?)?;
         Ok(())
     }
 

utils/src/lib.rs

@@ -73,6 +73,34 @@ pub mod as_slice;
 /// assert_eq!(test_struct, from_json);
 /// ```
 pub mod serde_bytes;
+
+/// # Examples
+/// ## Implement serde::Serialize/serde::Deserialize for the Vec field of the struct
+/// ```
+/// #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+/// struct MyStructVec {
+///     #[serde(with = "kaspa_utils::serde_bytes_optional")]
+///     v: Option<Vec<u8>>,
+/// }
+/// let v = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19];
+/// let len = v.len();
+/// let test_struct = MyStructVec { v: Some(v.clone()) };
+///
+///
+/// // Serialize using bincode
+/// let encoded = bincode::serialize(&test_struct).unwrap();
+/// assert_eq!(encoded, std::iter::once(1).chain(len.to_le_bytes().into_iter()).chain(v.into_iter()).collect::<Vec<_>>());
+/// // Deserialize using bincode
+/// let decoded: MyStructVec = bincode::deserialize(&encoded).unwrap();
+/// assert_eq!(test_struct, decoded);
+///
+/// let expected_str = r#"{"v":"000102030405060708090a0b0c0d0e0f10111213"}"#;
+/// // Serialize using serde_json
+/// let json = serde_json::to_string(&test_struct).unwrap();
+/// assert_eq!(expected_str, json);
+/// // Deserialize using serde_json
+/// let from_json: MyStructVec = serde_json::from_str(&json).unwrap();
+/// assert_eq!(test_struct, from_json);
 pub mod serde_bytes_optional;
 
 /// # Examples

wallet/bip32/src/lib.rs

@@ -19,6 +19,11 @@ mod prefix;
 mod result;
 pub mod types;
 
+pub mod wasm {
+    //! WASM bindings for the `bip32` module.
+    pub use crate::mnemonic::{Language, Mnemonic, WordCount};
+}
+
 pub use address_type::AddressType;
 pub use attrs::ExtendedKeyAttrs;
 pub use child_number::ChildNumber;

wallet/core/src/account/descriptor.rs

@@ -26,6 +26,7 @@ pub struct AccountDescriptor {
     pub prv_key_data_ids: AssocPrvKeyDataIds,
     pub receive_address: Option<Address>,
     pub change_address: Option<Address>,
+    pub addresses: Option<Vec<Address>>,
 
     pub properties: BTreeMap<AccountDescriptorProperty, AccountDescriptorValue>,
 }
@@ -39,6 +40,7 @@ impl AccountDescriptor {
         prv_key_data_ids: AssocPrvKeyDataIds,
         receive_address: Option<Address>,
         change_address: Option<Address>,
+        addresses: Option<Vec<Address>>,
     ) -> Self {
         Self {
             kind,
@@ -48,6 +50,7 @@ impl AccountDescriptor {
             prv_key_data_ids,
             receive_address,
             change_address,
+            addresses,
             properties: BTreeMap::default(),
         }
     }
@@ -241,6 +244,7 @@ declare! {
         accountName? : string,
         receiveAddress? : Address,
         changeAddress? : Address,
+        addresses? : Address[],
         prvKeyDataIds : HexString[],
         // balance? : Balance,
         [key: string]: any
@@ -259,6 +263,9 @@ impl TryFrom<AccountDescriptor> for IAccountDescriptor {
         object.set("receiveAddress", &descriptor.receive_address.into())?;
         object.set("changeAddress", &descriptor.change_address.into())?;
 
+        let addresses = js_sys::Array::from_iter(descriptor.addresses.into_iter().map(JsValue::from));
+        object.set("addresses", &addresses)?;
+
         let prv_key_data_ids = js_sys::Array::from_iter(descriptor.prv_key_data_ids.into_iter().map(JsValue::from));
         object.set("prvKeyDataIds", &prv_key_data_ids)?;