Update Javascript wallet bindings, replace wallet approach with the basic transaction building (#146)

- make a singVotes as a free function, not a method of the Wallet type
- remove Wallet type and Wallet usage from the Javascript bindings
- implement a simple TransactionBuilder type with the only transaction
building functionality.
- refactoring

Author: Mr-Leshiy

src/catalyst-toolbox/catalyst-toolbox/src/recovery/tally.rs

@@ -517,7 +517,8 @@ impl FragmentReplayer {
         let builder_help = wallet
             .new_transaction(tx.total_input().unwrap(), 0)
             .unwrap();
-        let mut builder = TransactionBuilder::new(&self.settings, vote_cast, tx.valid_until());
+        let mut builder =
+            TransactionBuilder::new(self.settings.clone(), vote_cast, tx.valid_until());
         builder.add_input(builder_help.input(), builder_help.witness_builder());
         let res = Fragment::VoteCast(builder.finalize_tx(()).unwrap());
 
@@ -567,7 +568,7 @@ impl FragmentReplayer {
         let builder_help = wallet
             .new_transaction(tx.total_input().unwrap(), 0)
             .unwrap();
-        let mut builder = TransactionBuilder::new(&self.settings, NoExtra, tx.valid_until());
+        let mut builder = TransactionBuilder::new(self.settings.clone(), NoExtra, tx.valid_until());
         builder.add_input(builder_help.input(), builder_help.witness_builder());
         builder.add_output(Output::from_address(output_address, output.value));
         let res = Fragment::Transaction(builder.finalize_tx(()).unwrap());

src/chain-libs/chain-impl-mockchain/src/accounting/account/mod.rs

@@ -31,13 +31,10 @@ pub enum LedgerError {
     AlreadyExists,
     #[error("Removed account is not empty")]
     NonZero,
-    #[error("Spending credential invalid, expected {} got {} in lane {}", .expected.unlaned_counter(), .actual.unlaned_counter(), .actual.lane())]
-    SpendingCredentialInvalid {
-        expected: SpendingCounter,
-        actual: SpendingCounter,
-    },
     #[error("Value calculation failed")]
     ValueError(#[from] ValueError),
+    #[error(transparent)]
+    SpendingCounterError(#[from] spending::Error),
 }
 
 impl From<UpdateError<LedgerError>> for LedgerError {

src/chain-libs/chain-impl-mockchain/src/accounting/account/spending.rs

@@ -1,5 +1,14 @@
 //! Spending strategies
-use super::LedgerError;
+#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
+pub enum Error {
+    #[error("Spending credential invalid, expected {} got {} in lane {}", .expected.unlaned_counter(), .actual.unlaned_counter(), .actual.lane())]
+    SpendingCredentialInvalid {
+        expected: SpendingCounter,
+        actual: SpendingCounter,
+    },
+    #[error("Invalid lane: {0} or counter: {1}, expected lane < (1 << LANES_BITS), counter < (1 << UNLANES_BITS)")]
+    InvalidLaneOrCounter(usize, u32),
+}
 
 /// Simple strategy to spend from multiple increasing counters
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -15,7 +24,7 @@ const LANES_BITS: usize = 3;
 const UNLANES_BITS: usize = 32 - LANES_BITS;
 
 impl SpendingCounterIncreasing {
-    /// number of parallel lanes of increasing counters
+    /// number of parallel lanes of increasing counters, equals to 8
     pub const LANES: usize = 1 << LANES_BITS;
 
     pub fn new_from_counter(set: SpendingCounter) -> Self {
@@ -46,14 +55,14 @@ impl SpendingCounterIncreasing {
     }
 
     /// try to match the lane of the counter in argument, if it doesn't match
-    /// a ledger error reported.
+    /// an error reported.
     ///
     /// If the counter match succesfully, then the counter at this lane is incremented by one.
-    pub fn next_verify(&mut self, counter: SpendingCounter) -> Result<(), LedgerError> {
+    pub fn next_verify(&mut self, counter: SpendingCounter) -> Result<(), Error> {
         let actual_counter = self.nexts[counter.lane()];
 
         if actual_counter != counter {
-            Err(LedgerError::SpendingCredentialInvalid {
+            Err(Error::SpendingCredentialInvalid {
                 expected: actual_counter,
                 actual: counter,
             })
@@ -78,7 +87,7 @@ impl Default for SpendingCounterIncreasing {
     fn default() -> Self {
         let mut nexts = Vec::new();
         for i in 0..Self::LANES {
-            nexts.push(SpendingCounter::new(i, 0));
+            nexts.push(SpendingCounter::new(i, 0).unwrap());
         }
         SpendingCounterIncreasing { nexts }
     }
@@ -115,10 +124,14 @@ impl SpendingCounter {
         self.0 & Self::UNLANED_MASK
     }
 
-    pub fn new(lane: usize, counter: u32) -> Self {
-        assert!(lane < (1 << LANES_BITS));
-        assert!(counter < (1 << UNLANES_BITS));
-        SpendingCounter((lane << UNLANES_BITS) as u32 | (counter & Self::UNLANED_MASK))
+    pub fn new(lane: usize, counter: u32) -> Result<Self, Error> {
+        if lane < (1 << LANES_BITS) || counter < (1 << UNLANES_BITS) {
+            Ok(SpendingCounter(
+                (lane << UNLANES_BITS) as u32 | (counter & Self::UNLANED_MASK),
+            ))
+        } else {
+            Err(Error::InvalidLaneOrCounter(lane, counter))
+        }
     }
 
     pub fn zero() -> Self {
@@ -175,18 +188,17 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
     fn new_invalid_spending_counter() {
         let lane: usize = (1 << LANES_BITS) + 1;
         let counter: u32 = 1 << UNLANES_BITS;
-        SpendingCounter::new(lane, counter);
+        assert!(SpendingCounter::new(lane, counter).is_err());
     }
 
     #[quickcheck_macros::quickcheck]
     fn new_spending_counter(mut lane: usize, mut counter: u32) {
         lane %= 1 << LANES_BITS;
         counter %= 1 << UNLANES_BITS;
-        let sc = SpendingCounter::new(lane, counter);
+        let sc = SpendingCounter::new(lane, counter).unwrap();
 
         assert_eq!(lane, sc.lane());
         assert_eq!(counter, sc.unlaned_counter());
@@ -220,14 +232,14 @@ mod tests {
     #[should_panic]
     #[cfg(debug_assertions)]
     fn increment_counter_overflow_debug() {
-        let _ = SpendingCounter::new(8, u32::MAX).increment();
+        let _ = SpendingCounter::new(8, u32::MAX).unwrap().increment();
     }
 
     #[test]
     #[should_panic]
     #[cfg(debug_assertions)]
     pub fn increment_nth_overflow_debug() {
-        let _ = SpendingCounter::new(0, 1).increment_nth(u32::MAX);
+        let _ = SpendingCounter::new(0, 1).unwrap().increment_nth(u32::MAX);
     }
 
     #[quickcheck_macros::quickcheck]
@@ -248,7 +260,10 @@ mod tests {
 
     #[test]
     pub fn spending_counters_incorrect_order() {
-        let counters = vec![SpendingCounter::new(1, 0), SpendingCounter::new(0, 0)];
+        let counters = vec![
+            SpendingCounter::new(1, 0).unwrap(),
+            SpendingCounter::new(0, 0).unwrap(),
+        ];
         assert!(SpendingCounterIncreasing::new_from_counters(counters).is_none());
     }
 
@@ -274,15 +289,14 @@ mod tests {
     #[test]
     pub fn spending_counter_increasing_wrong_counter() {
         let mut sc_increasing = SpendingCounterIncreasing::default();
-        let incorrect_sc = SpendingCounter::new(0, 100);
+        let incorrect_sc = SpendingCounter::new(0, 100).unwrap();
         assert!(sc_increasing.next_verify(incorrect_sc).is_err());
     }
 
     #[test]
-    #[should_panic]
     pub fn spending_counter_increasing_wrong_lane() {
         let mut sc_increasing = SpendingCounterIncreasing::default();
-        let incorrect_sc = SpendingCounter::new(SpendingCounterIncreasing::LANES, 1);
+        let incorrect_sc = SpendingCounter::new(SpendingCounterIncreasing::LANES, 1).unwrap();
         assert!(sc_increasing.next_verify(incorrect_sc).is_err());
     }
 

src/chain-libs/chain-impl-mockchain/src/ledger/tests/transaction_tests.rs

@@ -130,9 +130,12 @@ pub fn duplicated_account_transaction() {
     match result {
         Err(err) => panic!("first transaction should be succesful but {}", err),
         Ok(_) => match test_ledger.apply_transaction(fragment2, BlockDate::first()) {
-            Err(ledger::Error::Account(
-                crate::account::LedgerError::SpendingCredentialInvalid { expected, actual },
-            )) => {
+            Err(ledger::Error::Account(crate::account::LedgerError::SpendingCounterError(
+                crate::accounting::account::spending::Error::SpendingCredentialInvalid {
+                    expected,
+                    actual,
+                },
+            ))) => {
                 assert_eq!(expected, SpendingCounter::zero().increment());
                 assert_eq!(actual, SpendingCounter::zero());
             }

src/chain-libs/chain-impl-mockchain/src/testing/data/address.rs

@@ -1,6 +1,6 @@
 use crate::{
     account::Identifier,
-    account::SpendingCounter,
+    account::{LedgerError, SpendingCounter},
     accounting::account::SpendingCounterIncreasing,
     chaintypes::HeaderId,
     key::EitherEd25519SecretKey,
@@ -190,7 +190,9 @@ impl AddressData {
 
     pub fn confirm_transaction_at_lane(&mut self, lane: usize) -> Result<(), Error> {
         let sc = self.spending_counter_at_lane(lane)?;
-        self.spending_counter.next_verify(sc).map_err(Into::into)
+        self.spending_counter
+            .next_verify(sc)
+            .map_err(|e| LedgerError::SpendingCounterError(e).into())
     }
 
     pub fn spending_counter_at_lane(&self, lane: usize) -> Result<SpendingCounter, Error> {

src/chain-wallet-libs/bindings/wallet-core/src/lib.rs

@@ -1,10 +1,12 @@
 pub mod c;
 mod error;
+mod tx_builder;
 mod vote;
 mod wallet;
 
 pub use self::{
     error::{Error, ErrorCode, ErrorKind, Result},
+    tx_builder::TxBuilder,
     vote::Proposal,
     wallet::Wallet,
 };

src/chain-wallet-libs/bindings/wallet-core/src/tx_builder.rs

@@ -0,0 +1,50 @@
+use chain_crypto::SecretKey;
+use chain_impl_mockchain::{
+    account::SpendingCounter,
+    fragment::Fragment,
+    header::BlockDate,
+    transaction::{Input, Payload, Transaction},
+};
+use wallet::{EitherAccount, Settings};
+
+use crate::Error;
+
+pub struct TxBuilder<P: Payload> {
+    builder: wallet::TransactionBuilder<P>,
+}
+
+impl<P: Payload> TxBuilder<P> {
+    pub fn new(settings: Settings, valid_until: BlockDate, payload: P) -> Self {
+        let builder = wallet::TransactionBuilder::new(settings, payload, valid_until);
+        Self { builder }
+    }
+
+    pub fn build_tx(
+        mut self,
+        account_bytes: &[u8],
+        spending_counter: SpendingCounter,
+    ) -> Result<Self, Error> {
+        let account = EitherAccount::new_from_key(
+            SecretKey::from_binary(account_bytes)
+                .map_err(|e| Error::wallet_transaction().with(e))?,
+        );
+        // It is needed to provide a 1 extra input as we are generating it later, but should take into account at this place.
+        let value = self.builder.estimate_fee_with(1, 0);
+        let input = Input::from_account_public_key(account.account_id().into(), value);
+        let witness_builder = account.witness_builder(spending_counter);
+        self.builder.add_input(input, witness_builder);
+        Ok(self)
+    }
+
+    pub fn finalize_tx(
+        self,
+        auth: P::Auth,
+        fragment_build_fn: impl FnOnce(Transaction<P>) -> Fragment,
+    ) -> Result<Fragment, Error> {
+        Ok(fragment_build_fn(
+            self.builder
+                .finalize_tx(auth)
+                .map_err(|e| Error::wallet_transaction().with(e))?,
+        ))
+    }
+}

src/chain-wallet-libs/bindings/wallet-core/src/wallet.rs

@@ -103,7 +103,7 @@ impl Wallet {
 
     fn sign_transaction_impl<P: Payload>(
         &mut self,
-        settings: &Settings,
+        settings: Settings,
         valid_until: BlockDate,
         lane: u8,
         payload: P,
@@ -139,7 +139,7 @@ impl Wallet {
     /// This function outputs a fragment containing a signed transaction.
     pub fn sign_transaction(
         &mut self,
-        settings: &Settings,
+        settings: Settings,
         valid_until: BlockDate,
         lane: u8,
         certificate: Certificate,
@@ -183,7 +183,7 @@ impl Wallet {
             return Err(Error::wallet_vote_range());
         };
 
-        let mut builder = wallet::TransactionBuilder::new(&settings, payload, *valid_until);
+        let mut builder = wallet::TransactionBuilder::new(settings, payload, *valid_until);
 
         let value = builder.estimate_fee_with(1, 0);
 

src/chain-wallet-libs/bindings/wallet-wasm-js/Cargo.toml

@@ -31,6 +31,7 @@ wasm-bindgen = "0.2"
 js-sys = "0.3.40"
 bech32 = "0.7.2"
 serde_json = "1.0"
+hex = "0.4.2"
 
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires
@@ -45,4 +46,3 @@ clear_on_drop = {version = "0.2", features = ["no_cc"]}
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3"
-hex = "0.4.2"

src/chain-wallet-libs/bindings/wallet-wasm-js/js-test/test/vote_cast.js

@@ -1,60 +1,38 @@
 var assert = require("assert");
 
-const private_key = Buffer.from(
-  "c86596c2d1208885db1fe3658406aa0f7cc7b8e13c362fe46a6db277fc5064583e487588c98a6c36e2e7445c0add36f83f171cb5ccfd815509d19cd38ecb0af3",
-  "hex"
-);
+const private_key =
+  "c86596c2d1208885db1fe3658406aa0f7cc7b8e13c362fe46a6db277fc5064583e487588c98a6c36e2e7445c0add36f83f171cb5ccfd815509d19cd38ecb0af3";
 
 const settings_json =
   '{"fees":{"constant":10,"coefficient":2,"certificate":100},"discrimination":"production","block0_initial_hash":{"hash":"baf6b54817cf2a3e865f432c3922d28ac5be641e66662c66d445f141e409183e"},"block0_date":1586637936,"slot_duration":20,"time_era":{"epoch_start":0,"slot_start":0,"slots_per_epoch":180},"transaction_max_expiry_epochs":1}';
 
-function generate_wallet(wasm_wallet) {
-  let wallet = new wasm_wallet.Wallet(private_key, BigInt(1000));
-  assert(wallet.total_value() === BigInt(1000));
-  return wallet;
-}
-
 describe("vote cast certificate tests", function () {
   it("public", async function () {
-    const wasm_wallet = await import("wallet-js");
+    const wallet = await import("wallet-js");
 
-    let wallet = generate_wallet(wasm_wallet);
-    let settings = new wasm_wallet.Settings(settings_json);
-    let vote = wasm_wallet.Vote.public(
-      Buffer.from(
-        "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
-        "hex"
-      ),
-      8,
-      0
+    let settings = new wallet.Settings(settings_json);
+    let proposal = new wallet.Proposal(
+      "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+      2,
+      8
     );
-
-    let block_date = wasm_wallet.BlockDate.new(0, 1);
-    let fragments = wallet.signVotes([vote], settings, block_date, 0);
+    let vote = new wallet.Vote(proposal, 0, new wallet.BlockDate(0, 1), 1, 1);
+    let fragments = wallet.signVotes([vote], settings, private_key);
     assert(fragments.length == 1);
   });
 
   it("private", async function () {
-    const wasm_wallet = await import("wallet-js");
+    const wallet = await import("wallet-js");
 
-    let wallet = generate_wallet(wasm_wallet);
-    let settings = new wasm_wallet.Settings(settings_json);
-    let vote = wasm_wallet.Vote.private(
-      Buffer.from(
-        "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
-        "hex"
-      ),
-      8,
+    let settings = new wallet.Settings(settings_json);
+    let proposal = new wallet.Proposal(
+      "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
       4,
-      0,
-      Buffer.from(
-        "bed88887abe0a84f64691fe0bdfa3daf1a6cd697a13f07ae07588910ce39c927",
-        "hex"
-      )
+      8,
+      "bed88887abe0a84f64691fe0bdfa3daf1a6cd697a13f07ae07588910ce39c927"
     );
-
-    let block_date = wasm_wallet.BlockDate.new(0, 1);
-    let fragments = wallet.signVotes([vote], settings, block_date, 0);
+    let vote = new wallet.Vote(proposal, 0, new wallet.BlockDate(0, 1), 1, 1);
+    let fragments = wallet.signVotes([vote], settings, private_key);
     assert(fragments.length == 1);
   });
 });