From 30b6405dfa6cf080a787d5e728043d6911c1d1cb Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 19:58:10 +0100
Subject: [PATCH 01/24] Added multisig wallet

---
 .../Types/WalletMultisig.cs                   | 292 ++++++++++++++++++
 1 file changed, 292 insertions(+)
 create mode 100644 src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs

diff --git a/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs b/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
new file mode 100644
index 000000000..82be6b7c0
--- /dev/null
+++ b/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
@@ -0,0 +1,292 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Blockcore.Consensus.ScriptInfo;
+using Blockcore.Features.Wallet.Helpers;
+using Blockcore.Features.Wallet.Interfaces;
+using Blockcore.Networks;
+using Blockcore.Utilities.JsonConverters;
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace Blockcore.Features.Wallet.Types
+{
+    public class WalletMultisig : Wallet
+    {
+        public WalletMultisig(List<AccountRootMultisig> accountsRoot, ICollection<uint256> blockLocator, byte[] chaincode, DateTimeOffset creationTime, string name, Network network)
+        {
+            this.AccountsRoot = (ICollection<IAccountRoot>)accountsRoot;
+            this.BlockLocator = blockLocator;
+            this.ChainCode = chaincode;
+            this.CreationTime = creationTime;
+            this.EncryptedSeed = string.Empty;
+            this.IsMultisig = true;
+            this.IsExtPubKeyWallet = true;
+            this.Name = name;
+            this.Network = network;
+        }
+        public WalletMultisig()
+        {
+            this.IsMultisig = true;
+            this.EncryptedSeed = string.Empty;
+            this.AccountsRoot = new List<IAccountRoot>();
+        }
+
+        public WalletMultisig(Network network):this()
+        {
+            this.Network = network;            
+        }
+        /// <summary>
+        /// The root of the accounts tree.
+        /// </summary>
+        [JsonConverter(typeof(AccountRootMultisigConverter))]
+        [JsonProperty(PropertyName = "accountsRoot")]
+        public override ICollection<IAccountRoot> AccountsRoot { get; set; }
+        /// <summary>
+        /// Adds an account to the current wallet.
+        /// </summary>
+        /// <remarks>
+        /// The name given to the account is of the form "account (i)" by default, where (i) is an incremental index starting at 0.
+        /// According to BIP44, an account at index (i) can only be created when the account at index (i - 1) contains at least one transaction.
+        /// </remarks>
+        /// <seealso cref="https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki"/>
+        /// <param name="password">The password used to decrypt the wallet's <see cref="EncryptedSeed"/>.</param>
+        /// <param name="coinType">The type of coin this account is for.</param>
+        /// <param name="accountCreationTime">Creation time of the account to be created.</param>
+        /// <returns>A new HD account.</returns>
+        public HdAccountMultisig AddNewAccount(MultisigScheme scheme, int coinType, DateTimeOffset accountCreationTime)
+        {
+            return AddNewAccount(scheme, coinType, this.Network, accountCreationTime);
+        }
+
+        /// <summary>
+        /// Creates an account as expected in bip-44 account structure.
+        /// </summary>
+        /// <param name="chainCode"></param>
+        /// <param name="network"></param>
+        /// <param name="accountCreationTime"></param>
+        /// <returns></returns>
+        public HdAccountMultisig AddNewAccount(MultisigScheme multisigScheme, int coinType, Network network, DateTimeOffset accountCreationTime)
+        {
+            // Get the current collection of accounts.
+            var accounts = this.AccountsRoot.FirstOrDefault().Accounts;
+
+            int newAccountIndex = 0;
+            if (accounts.Any())
+            {
+                newAccountIndex = accounts.Max(a => a.Index) + 1;
+            }
+
+            string accountHdPath = $"m/45'/{(int)coinType}'/{newAccountIndex}'";
+
+            var newAccount = new HdAccountMultisig(multisigScheme)
+            {
+                Index = newAccountIndex,
+                ExternalAddresses = new List<HdAddress>(),
+                InternalAddresses = new List<HdAddress>(),
+                Name = $"account {newAccountIndex}",
+                HdPath = accountHdPath,
+                CreationTime = accountCreationTime
+            };
+
+            accounts.Add(newAccount);
+
+            return newAccount;
+        }
+
+    }
+
+    /// <summary>
+    /// Provides owerrden mothods for account creation in multisig wallet.
+    /// </summary>
+    public class AccountRootMultisig : AccountRoot, IAccountRoot
+    {
+        public AccountRootMultisig(List<HdAccountMultisig> accounts, int? coinType, uint256 lastBlockSyncedHash, int? lastBlockSyncedHeight)
+        {
+            this.Accounts = (ICollection<IHdAccount>)accounts;
+            this.CoinType = coinType;
+            this.LastBlockSyncedHash = lastBlockSyncedHash;
+            this.LastBlockSyncedHeight = lastBlockSyncedHeight;
+        }
+       
+        public AccountRootMultisig()
+        {
+            this.Accounts = new List<IHdAccount>();
+        }
+
+        [JsonConverter(typeof(HdAccountMultisigConverter))]
+        [JsonProperty(PropertyName = "accounts")]
+        public override ICollection<IHdAccount> Accounts { get; set; }
+    }
+
+    public class AccountRootMultisigConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            //assume we can convert to anything for now
+            return true;
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (objectType == typeof(ICollection<IAccountRoot>))
+            {
+                List<IAccountRoot> accountRoots = new List<IAccountRoot>();
+                var list = serializer.Deserialize<List<AccountRootMultisig>>(reader);
+
+                foreach (var item in list)
+                {
+                    accountRoots.Add(item);
+                }
+                return accountRoots;
+            }
+         
+            return null;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            //use the default serialization - it works fine
+            serializer.Serialize(writer, value);
+        }
+    }
+
+    public class HdAccountMultisigConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            //assume we can convert to anything for now
+            return true;
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (objectType == typeof(ICollection<IHdAccount>))
+            {
+                List<IHdAccount> accounts = new List<IHdAccount>();
+                var list = serializer.Deserialize<List<HdAccountMultisig>>(reader);
+                foreach (var item in list)
+                {
+                    accounts.Add(item);
+                }
+                return accounts;
+            }
+            return null;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            //use the default serialization - it works fine
+            serializer.Serialize(writer, value);
+        }
+    }
+    public class HdAccountMultisig : HdAccount, IHdAccount
+    {
+        public HdAccountMultisig(MultisigScheme scheme)
+        {
+            this.ExtendedPubKey = "N/A";
+            this.MultisigScheme = scheme;
+        }      
+
+        [JsonProperty(PropertyName = "multisigScheme")]
+        public MultisigScheme MultisigScheme { get; set; }
+        /// Generates an HD public key derived from an extended public key.
+        /// </summary>
+        /// <param name="accountExtPubKey">The extended public key used to generate child keys.</param>
+        /// <param name="index">The index of the child key to generate.</param>
+        /// <param name="isChange">A value indicating whether the public key to generate corresponds to a change address.</param>
+        /// <returns>
+        /// An HD public key derived from an extended public key.
+        /// </returns>
+
+        public Script GeneratePublicKey(int hdPathIndex, bool isChange = false)
+        {
+            List<PubKey> derivedPubKeys = new List<PubKey>();
+            foreach (var xpub in this.MultisigScheme.XPubs)
+            {
+                derivedPubKeys.Add(HdOperations.GeneratePublicKey(xpub, hdPathIndex, isChange));
+            }
+            var sortedkeys = LexographicalSort(derivedPubKeys);
+
+            Script redeemScript = PayToMultiSigTemplate.Instance.GenerateScriptPubKey(this.MultisigScheme.Threashold, sortedkeys.ToArray());
+            return redeemScript;
+        }
+
+
+
+        /// <summary>
+        /// Creates a number of additional addresses in the current account.
+        /// </summary>
+        /// <remarks>
+        /// The name given to the account is of the form "account (i)" by default, where (i) is an incremental index starting at 0.
+        /// According to BIP44, an account at index (i) can only be created when the account at index (i - 1) contains at least one transaction.
+        /// </remarks>
+        /// <param name="wallet">Instance of a multisig wallet that allows access to multisig scheme, pubkeys threashold and etc</param>
+        /// <param name="addressesQuantity">The number of addresses to create.</param>
+        /// <param name="isChange">Whether the addresses added are change (internal) addresses or receiving (external) addresses.</param>
+        /// <returns>The created addresses.</returns>
+        public override IEnumerable<HdAddress> CreateAddresses(Network network, int addressesQuantity, bool isChange = false)
+        {
+            var addresses = isChange ? this.InternalAddresses : this.ExternalAddresses;
+
+            // Get the index of the last address.
+            int firstNewAddressIndex = 0;
+            if (addresses.Any())
+            {
+                firstNewAddressIndex = addresses.Max(add => add.Index) + 1;
+            }
+
+            List<HdAddress> addressesCreated = new List<HdAddress>();
+            for (int i = firstNewAddressIndex; i < firstNewAddressIndex + addressesQuantity; i++)
+            {
+                // Generate a new address.                
+                var pubkey = GeneratePublicKey(i, isChange);
+                BitcoinAddress address = pubkey.Hash.GetAddress(network);
+                // Add the new address details to the list of addresses.
+                HdAddress newAddress = new HdAddress
+                {
+                    Index = i,
+                    HdPath = CreateHdPath((int)this.GetCoinType(), this.Index, i, isChange),
+                    ScriptPubKey = address.ScriptPubKey,
+                    Pubkey = pubkey,
+                    Address = address.ToString(),
+                    RedeemScript = pubkey
+                    //Transactions = new List<TransactionData>()
+                };
+
+                addresses.Add(newAddress);
+                addressesCreated.Add(newAddress);
+            }
+
+            if (isChange)
+            {
+                this.InternalAddresses = addresses;
+            }
+            else
+            {
+                this.ExternalAddresses = addresses;
+            }
+
+            return addressesCreated;
+        }
+
+        public static string CreateHdPath(int coinType, int accountIndex, int addressIndex, bool isChange = false)
+        {
+            int change = isChange ? 1 : 0;
+            return $"m/45'/{coinType}'/{accountIndex}'/{change}/{addressIndex}";
+        }
+
+        private static IEnumerable<PubKey> LexographicalSort(IEnumerable<PubKey> pubKeys)
+        {
+            List<PubKey> list = new List<PubKey>();
+            var e = pubKeys.Select(s => s.ToHex());
+            var sorted = e.OrderByDescending(s => s.Length).ThenBy(r => r);
+            foreach (var item in sorted)
+            {
+                list.Add(new PubKey(item));
+            }
+            return list;
+        }
+    }
+}
+

From 1cd66799b9b5ec0bda9186bfad9d1d4f62586c40 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:07:34 +0100
Subject: [PATCH 02/24] Extracting root account interface so that it can be
 substituted

Extracting root account interface so that it can be substituted by multisig wallet classes
---
 .../Interfaces/IAccountRoot.cs                | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 src/Features/Blockcore.Features.Wallet/Interfaces/IAccountRoot.cs

diff --git a/src/Features/Blockcore.Features.Wallet/Interfaces/IAccountRoot.cs b/src/Features/Blockcore.Features.Wallet/Interfaces/IAccountRoot.cs
new file mode 100644
index 000000000..b50e7a303
--- /dev/null
+++ b/src/Features/Blockcore.Features.Wallet/Interfaces/IAccountRoot.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using Blockcore.Features.Wallet.Database;
+using Blockcore.Networks;
+using NBitcoin;
+
+namespace Blockcore.Features.Wallet.Interfaces
+{
+    public interface IAccountRoot
+    {
+        ICollection<IHdAccount> Accounts { get; set; }
+        int? CoinType { get; set; }
+        uint256 LastBlockSyncedHash { get; set; }
+        int? LastBlockSyncedHeight { get; set; }
+
+        IHdAccount AddNewAccount(ExtPubKey accountExtPubKey, int accountIndex, Network network, DateTimeOffset accountCreationTime);
+        IHdAccount AddNewAccount(string password, string encryptedSeed, byte[] chainCode, Network network, DateTimeOffset accountCreationTime, int? accountIndex = null, string accountName = null);
+        IHdAccount CreateAccount(string password, string encryptedSeed, byte[] chainCode, Network network, DateTimeOffset accountCreationTime, int newAccountIndex, string newAccountName = null);
+        IHdAccount GetAccountByName(string accountName);
+        IHdAccount GetFirstUnusedAccount(IWalletStore walletStore);
+    }
+}
\ No newline at end of file

From 31211329b1416a20db05e7f2be2ebf8d8c8adc9a Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:08:21 +0100
Subject: [PATCH 03/24] Extracting account interface so that it can be
 substituted

Extracting account interface so that it can be substituted by multisig wallet classes
---
 .../Interfaces/IHdAccount.cs                  | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 src/Features/Blockcore.Features.Wallet/Interfaces/IHdAccount.cs

diff --git a/src/Features/Blockcore.Features.Wallet/Interfaces/IHdAccount.cs b/src/Features/Blockcore.Features.Wallet/Interfaces/IHdAccount.cs
new file mode 100644
index 000000000..1750c591c
--- /dev/null
+++ b/src/Features/Blockcore.Features.Wallet/Interfaces/IHdAccount.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using Blockcore.Features.Wallet.Database;
+using Blockcore.Features.Wallet.Types;
+using Blockcore.Networks;
+using NBitcoin;
+
+namespace Blockcore.Features.Wallet.Interfaces
+{
+    public interface IHdAccount
+    {
+        DateTimeOffset CreationTime { get; set; }
+        string ExtendedPubKey { get; set; }
+        ICollection<HdAddress> ExternalAddresses { get; set; }
+        string HdPath { get; set; }
+        int Index { get; set; }
+        ICollection<HdAddress> InternalAddresses { get; set; }
+        string Name { get; set; }
+
+        IEnumerable<HdAddress> CreateAddresses(Network network, int addressesQuantity, bool isChange = false);
+        (Money ConfirmedAmount, Money UnConfirmedAmount) GetBalances(IWalletStore walletStore, bool excludeColdStakeUtxo);
+        int GetCoinType();
+        IEnumerable<HdAddress> GetCombinedAddresses();
+        HdAddress GetFirstUnusedChangeAddress(IWalletStore walletStore);
+        HdAddress GetFirstUnusedReceivingAddress(IWalletStore walletStore);
+        HdAddress GetLastUsedAddress(IWalletStore walletStore, bool isChange);
+        IEnumerable<UnspentOutputReference> GetSpendableTransactions(IWalletStore walletStore, int currentChainHeight, long coinbaseMaturity, int confirmations = 0);
+        bool IsNormalAccount();
+    }
+}
\ No newline at end of file

From 39459b3a4c692cf6f3e0ec221c1f269d5ab3edc1 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:09:32 +0100
Subject: [PATCH 04/24] Adding multisig scheme class

---
 .../Types/MultisigScheme.cs                   | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 src/Features/Blockcore.Features.Wallet/Types/MultisigScheme.cs

diff --git a/src/Features/Blockcore.Features.Wallet/Types/MultisigScheme.cs b/src/Features/Blockcore.Features.Wallet/Types/MultisigScheme.cs
new file mode 100644
index 000000000..beb5dda2d
--- /dev/null
+++ b/src/Features/Blockcore.Features.Wallet/Types/MultisigScheme.cs
@@ -0,0 +1,19 @@
+using Newtonsoft.Json;
+
+namespace Blockcore.Features.Wallet.Types
+{
+    public class MultisigScheme
+    {
+        /// <summary>
+        /// How many signatures will be suffient to move the funds.
+        /// </summary>
+        [JsonProperty(PropertyName = "threashold")]
+        public int Threashold { get; set; }
+
+        /// <summary>
+        /// Cosigner extended pubkeys. Intentionally not including any xPriv at this stage as such model is simplest to start with.
+        /// </summary>
+        [JsonProperty(PropertyName = "xPubs")]
+        public string[] XPubs { get; set; }
+    }
+}

From f8e60a48fb2192d3e0821450344c4e42a1ec6572 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:10:14 +0100
Subject: [PATCH 05/24] Testing multisig address derivation

---
 .../MultisigWalletTest.cs                     | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 src/Tests/Blockcore.Features.Wallet.Tests/MultisigWalletTest.cs

diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/MultisigWalletTest.cs b/src/Tests/Blockcore.Features.Wallet.Tests/MultisigWalletTest.cs
new file mode 100644
index 000000000..ae915601e
--- /dev/null
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/MultisigWalletTest.cs
@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Blockcore.Consensus.ScriptInfo;
+using Blockcore.Features.Wallet.Types;
+using Blockcore.Networks;
+using Blockcore.Networks.XRC;
+using Xunit;
+
+namespace Blockcore.Features.Wallet.Tests
+{
+    public class MultisigWalletTest
+    {
+        private readonly Network network;
+        private readonly MultisigScheme multisigScheme;
+        private const int COINTYPE = 10291;
+        public MultisigWalletTest()
+        {
+            this.network = new XRCMain();
+            this.multisigScheme = new MultisigScheme()
+            {
+                Threashold = 2,
+                XPubs = new string[]
+                {
+                    "xpub661MyMwAqRbcFK4g9bHwLNYLmy4JxSFkKNRURL3hJqVYLoZ318eHmEKjMbFxbgDiaMycDk4oixtRkHKgbopRzukzimmyzAb2aEVfAEeJPxt",
+                    "xpub661MyMwAqRbcFVViGz3WGiaYgzsKWKXYduJZ8oR4tnnaRLp2QXMUf5P9Yq6CpJ8zuddutUFyrTkMECqqa1UyjnegVpoiYbcqpJfSCP9GcmG",
+                    "xpub661MyMwAqRbcFYCYnw23jLqPAHMvCfmLeKkmDSLGy6nGpVtJvN9EDoR2qdz8fmvkV8sSa1ZT7j8oyfBgjHKX2nGnESLqSndrM2gJ6TGcXrU",
+                }
+            };
+        }
+
+        [Fact]
+        public void Generate1stMultisigAddress()
+        {
+
+            WalletMultisig wallet = new WalletMultisig(this.network);
+            var root = new AccountRootMultisig
+            {
+                CoinType = COINTYPE
+            };
+            wallet.AccountsRoot.Add(root);
+            var account = wallet.AddNewAccount(this.multisigScheme, COINTYPE, DateTimeOffset.UtcNow);
+
+            Script redeemScript = account.GeneratePublicKey(0);
+            Assert.Equal("rbAxG3vTMCuVMWppaobvTajBtUHSiFtkr5", redeemScript.Hash.GetAddress(this.network).ToString());
+        }
+
+        [Fact]
+        public void Generate4SequnetialMultisigRecievingAndChangeAddress()
+        {
+            string[] receiving = { "rbAxG3vTMCuVMWppaobvTajBtUHSiFtkr5", "roLKXofxDFrkZqW7kU9aD7j7E6pTajEe16", "rjmcR79w6MatNK3KeHR3FvaEEHngdAKa9h", "reD6MyXPFUaJpyBtJVDgdYf7iN4qHbhzBz" };
+            string[] change = { "rXh3PVYpn462fDTAmLiUyKZ1aTWdzr4W9J", "rjNVcwuXKW1d8j8CQbxK4Kim5Hkg7Z4ZhL", "rginUKQEG9XjQVfhJ5ho7P4v9ENrtvF8Uk", "rgeVtHemGFGQzRU2Dhj3gYTgsWcjg4wgG5" };
+
+            WalletMultisig wallet = new WalletMultisig(this.network);
+            var root = new AccountRootMultisig
+            {
+                CoinType = COINTYPE
+            };
+            wallet.AccountsRoot.Add(root);
+            var account = wallet.AddNewAccount(this.multisigScheme, COINTYPE, DateTimeOffset.UtcNow);
+
+            for (int i = 0; i < receiving.Length; i++)
+            {
+                Script redeemScript = account.GeneratePublicKey(i);
+                Assert.Equal(receiving[i], redeemScript.Hash.GetAddress(this.network).ToString());
+            }
+
+            for (int i = 0; i < change.Length; i++)
+            {
+                Script redeemScript = account.GeneratePublicKey(i, true);
+                Assert.Equal(change[i], redeemScript.Hash.GetAddress(this.network).ToString());
+            }
+        }
+    }
+}

From 736a8a4f8391c0894ce7d9d65dc58778fd987ae9 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:11:45 +0100
Subject: [PATCH 06/24] Changing wallet class use interfaces instead of
 concrete classes

---
 .../Blockcore.Features.Wallet/Types/Wallet.cs | 132 ++++++++++++------
 1 file changed, 93 insertions(+), 39 deletions(-)

diff --git a/src/Features/Blockcore.Features.Wallet/Types/Wallet.cs b/src/Features/Blockcore.Features.Wallet/Types/Wallet.cs
index 3554c7231..0423e95b7 100644
--- a/src/Features/Blockcore.Features.Wallet/Types/Wallet.cs
+++ b/src/Features/Blockcore.Features.Wallet/Types/Wallet.cs
@@ -7,6 +7,7 @@
 using Blockcore.Features.Wallet.Database;
 using Blockcore.Features.Wallet.Exceptions;
 using Blockcore.Features.Wallet.Helpers;
+using Blockcore.Features.Wallet.Interfaces;
 using Blockcore.Networks;
 using Blockcore.Utilities;
 using Blockcore.Utilities.JsonConverters;
@@ -27,17 +28,17 @@ public class Wallet
         public const int SpecialPurposeAccountIndexesStart = 100_000_000;
 
         /// <summary>Filter for identifying normal wallet accounts.</summary>
-        public static Func<HdAccount, bool> NormalAccounts = a => a.Index < SpecialPurposeAccountIndexesStart;
+        public static Func<IHdAccount, bool> NormalAccounts = a => a.Index < SpecialPurposeAccountIndexesStart;
 
         /// <summary>Filter for all wallet accounts.</summary>
-        public static Func<HdAccount, bool> AllAccounts = a => true;
+        public static Func<IHdAccount, bool> AllAccounts = a => true;
 
         /// <summary>
         /// Initializes a new instance of the wallet.
         /// </summary>
         public Wallet()
         {
-            this.AccountsRoot = new List<AccountRoot>();
+            this.AccountsRoot = new List<IAccountRoot>();
         }
 
         [JsonIgnore]
@@ -92,15 +93,19 @@ public Wallet()
         /// <summary>
         /// The root of the accounts tree.
         /// </summary>
+        [JsonConverter(typeof(AccountRootConverter))]
         [JsonProperty(PropertyName = "accountsRoot")]
-        public ICollection<AccountRoot> AccountsRoot { get; set; }
+        public virtual ICollection<IAccountRoot> AccountsRoot { get; set; }
+
+        [JsonProperty(PropertyName = "isMultisig")]
+        public bool IsMultisig { get; set; }
 
         /// <summary>
         /// Gets the accounts in the wallet.
         /// </summary>
         /// <param name="accountFilter">An optional filter for filtering the accounts being returned.</param>
         /// <returns>The accounts in the wallet.</returns>
-        public IEnumerable<HdAccount> GetAccounts(Func<HdAccount, bool> accountFilter = null)
+        public IEnumerable<IHdAccount> GetAccounts(Func<IHdAccount, bool> accountFilter = null)
         {
             return this.AccountsRoot.SelectMany(a => a.Accounts).Where(accountFilter ?? NormalAccounts);
         }
@@ -110,7 +115,7 @@ public IEnumerable<HdAccount> GetAccounts(Func<HdAccount, bool> accountFilter =
         /// </summary>
         /// <param name="accountName">The name of the account to retrieve.</param>
         /// <returns>The requested account or <c>null</c> if the account does not exist.</returns>
-        public HdAccount GetAccount(string accountName)
+        public IHdAccount GetAccount(string accountName)
         {
             return this.AccountsRoot.SingleOrDefault()?.GetAccountByName(accountName);
         }
@@ -121,7 +126,7 @@ public HdAccount GetAccount(string accountName)
         /// <param name="block">The block whose details are used to update the wallet.</param>
         public void SetLastBlockDetails(ChainedHeader block)
         {
-            AccountRoot accountRoot = this.AccountsRoot.SingleOrDefault();
+            IAccountRoot accountRoot = this.AccountsRoot.SingleOrDefault();
 
             if (accountRoot == null)
             {
@@ -136,9 +141,9 @@ public void SetLastBlockDetails(ChainedHeader block)
         /// Gets all the transactions in the wallet.
         /// </summary>
         /// <returns>A list of all the transactions in the wallet.</returns>
-        public IEnumerable<TransactionOutputData> GetAllTransactions(Func<HdAccount, bool> accountFilter = null)
+        public IEnumerable<TransactionOutputData> GetAllTransactions(Func<IHdAccount, bool> accountFilter = null)
         {
-            List<HdAccount> accounts = this.GetAccounts(accountFilter).ToList();
+            List<IHdAccount> accounts = this.GetAccounts(accountFilter).ToList();
 
             // First we iterate normal accounts
             foreach (TransactionOutputData txData in accounts.Where(a => a.IsNormalAccount()).SelectMany(x => x.ExternalAddresses).SelectMany(x => this.walletStore.GetForAddress(x.Address)))
@@ -181,7 +186,7 @@ public IEnumerable<TransactionOutputData> GetAllTransactions(Func<HdAccount, boo
         /// <returns>A list of all the public keys contained in the wallet.</returns>
         public IEnumerable<Script> GetAllPubKeys()
         {
-            List<HdAccount> accounts = this.GetAccounts().ToList();
+            List<IHdAccount> accounts = this.GetAccounts().ToList();
 
             foreach (Script script in accounts.SelectMany(x => x.ExternalAddresses).Select(x => x.ScriptPubKey))
             {
@@ -199,9 +204,9 @@ public IEnumerable<Script> GetAllPubKeys()
         /// </summary>
         /// <param name="accountFilter">An optional filter for filtering the accounts being returned.</param>
         /// <returns>A list of all the addresses contained in this wallet.</returns>
-        public IEnumerable<HdAddress> GetAllAddresses(Func<HdAccount, bool> accountFilter = null)
+        public IEnumerable<HdAddress> GetAllAddresses(Func<IHdAccount, bool> accountFilter = null)
         {
-            IEnumerable<HdAccount> accounts = this.GetAccounts(accountFilter);
+            IEnumerable<IHdAccount> accounts = this.GetAccounts(accountFilter);
 
             var allAddresses = new List<HdAddress>();
             foreach (HdAccount account in accounts)
@@ -224,11 +229,11 @@ public IEnumerable<HdAddress> GetAllAddresses(Func<HdAccount, bool> accountFilte
         /// <param name="accountIndex">The index at which an account will be created. If left null, a new account will be created after the last used one.</param>
         /// <param name="accountName">The name of the account to be created. If left null, an account will be created according to the <see cref="Wallet.AccountNamePattern"/>.</param>
         /// <returns>A new HD account.</returns>
-        public HdAccount AddNewAccount(string password, DateTimeOffset accountCreationTime, int? accountIndex = null, string accountName = null)
+        public IHdAccount AddNewAccount(string password, DateTimeOffset accountCreationTime, int? accountIndex = null, string accountName = null)
         {
             Guard.NotEmpty(password, nameof(password));
 
-            AccountRoot accountRoot = this.AccountsRoot.Single();
+            IAccountRoot accountRoot = this.AccountsRoot.Single();
             return accountRoot.AddNewAccount(password, this.EncryptedSeed, this.ChainCode, this.Network, accountCreationTime, accountIndex, accountName);
         }
 
@@ -244,9 +249,9 @@ public HdAccount AddNewAccount(string password, DateTimeOffset accountCreationTi
         /// <param name="accountIndex">Zero-based index of the account to add.</param>
         /// <param name="accountCreationTime">Creation time of the account to be created.</param>
         /// <returns>A new HD account.</returns>
-        public HdAccount AddNewAccount(ExtPubKey extPubKey, int accountIndex, DateTimeOffset accountCreationTime)
+        public IHdAccount AddNewAccount(ExtPubKey extPubKey, int accountIndex, DateTimeOffset accountCreationTime)
         {
-            AccountRoot accountRoot = this.AccountsRoot.Single();
+            IAccountRoot accountRoot = this.AccountsRoot.Single();
             return accountRoot.AddNewAccount(extPubKey, accountIndex, this.Network, accountCreationTime);
         }
 
@@ -254,15 +259,15 @@ public HdAccount AddNewAccount(ExtPubKey extPubKey, int accountIndex, DateTimeOf
         /// Gets the first account that contains no transaction.
         /// </summary>
         /// <returns>An unused account.</returns>
-        public HdAccount GetFirstUnusedAccount(IWalletStore walletStore)
+        public IHdAccount GetFirstUnusedAccount(IWalletStore walletStore)
         {
             // Get the accounts root for this type of coin.
-            AccountRoot accountsRoot = this.AccountsRoot.Single();
+            IAccountRoot accountsRoot = this.AccountsRoot.Single();
 
             if (accountsRoot.Accounts.Any())
             {
                 // Get an unused account.
-                HdAccount firstUnusedAccount = accountsRoot.GetFirstUnusedAccount(walletStore);
+                IHdAccount firstUnusedAccount = accountsRoot.GetFirstUnusedAccount(walletStore);
                 if (firstUnusedAccount != null)
                 {
                     return firstUnusedAccount;
@@ -318,9 +323,9 @@ public ISecret GetExtendedPrivateKeyForAddress(string password, HdAddress addres
         /// <param name="confirmations">The number of confirmations required to consider a transaction spendable.</param>
         /// <param name="accountFilter">An optional filter for filtering the accounts being returned.</param>
         /// <returns>A collection of spendable outputs.</returns>
-        public IEnumerable<UnspentOutputReference> GetAllSpendableTransactions(IWalletStore walletStore, int currentChainHeight, int confirmations = 0, Func<HdAccount, bool> accountFilter = null)
+        public IEnumerable<UnspentOutputReference> GetAllSpendableTransactions(IWalletStore walletStore, int currentChainHeight, int confirmations = 0, Func<IHdAccount, bool> accountFilter = null)
         {
-            IEnumerable<HdAccount> accounts = this.GetAccounts(accountFilter);
+            IEnumerable<IHdAccount> accounts = this.GetAccounts(accountFilter);
 
             return accounts.SelectMany(x => x.GetSpendableTransactions(walletStore, currentChainHeight, this.Network.Consensus.CoinbaseMaturity, confirmations));
         }
@@ -333,9 +338,9 @@ public IEnumerable<UnspentOutputReference> GetAllSpendableTransactions(IWalletSt
         /// <param name="confirmations">The number of confirmations required to consider a transaction spendable.</param>
         /// <param name="accountFilter">An optional filter for filtering the accounts being returned.</param>
         /// <returns>A collection of spendable outputs.</returns>
-        public IEnumerable<UnspentOutputReference> GetAllUnspentTransactions(IWalletStore walletStore, int currentChainHeight, int confirmations = 0, Func<HdAccount, bool> accountFilter = null)
+        public IEnumerable<UnspentOutputReference> GetAllUnspentTransactions(IWalletStore walletStore, int currentChainHeight, int confirmations = 0, Func<IHdAccount, bool> accountFilter = null)
         {
-            IEnumerable<HdAccount> accounts = this.GetAccounts(accountFilter);
+            IEnumerable<IHdAccount> accounts = this.GetAccounts(accountFilter);
 
             // The logic for retrieving unspent transactions is almost identical to determining spendable transactions, we just don't take coinbase/stake maturity into consideration.
             return accounts.SelectMany(x => x.GetSpendableTransactions(walletStore, currentChainHeight, 0, confirmations));
@@ -380,31 +385,55 @@ public Money GetSentTransactionFee(uint256 transactionId)
         /// <param name="address">An address.</param>
         /// <param name="accountFilter">An optional filter for filtering the accounts being returned.</param>
         /// <returns>HD Address</returns>
-        public HdAddress GetAddress(string address, Func<HdAccount, bool> accountFilter = null)
+        public HdAddress GetAddress(string address, Func<IHdAccount, bool> accountFilter = null)
         {
             Guard.NotNull(address, nameof(address));
             return this.GetAllAddresses(accountFilter).SingleOrDefault(a => a.Address == address || a.Bech32Address == address);
         }
     }
 
+    public class AccountRootConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        { 
+            return true;
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            List<IAccountRoot> accounts = new List<IAccountRoot>();
+            var list = serializer.Deserialize<List<AccountRoot>>(reader);
+            foreach (var item in list)
+            {
+                accounts.Add(item);
+            }
+            return accounts;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            serializer.Serialize(writer, value);
+        }
+    }
+
     /// <summary>
     /// The root for the accounts for any type of coins.
     /// </summary>
-    public class AccountRoot
+    public class AccountRoot : IAccountRoot
     {
         /// <summary>
         /// Initializes a new instance of the object.
         /// </summary>
         public AccountRoot()
         {
-            this.Accounts = new List<HdAccount>();
+            this.Accounts = new List<IHdAccount>();
         }
 
         /// <summary>
         /// The type of coin, Bitcoin or Stratis.
         /// </summary>
         [JsonProperty(PropertyName = "coinType")]
-        public int CoinType { get; set; }
+        public int? CoinType { get; set; }
 
         /// <summary>
         /// The height of the last block that was synced.
@@ -424,19 +453,20 @@ public AccountRoot()
         /// <summary>
         /// The accounts used in the wallet.
         /// </summary>
+        [JsonConverter(typeof(HdAccountConverter))]
         [JsonProperty(PropertyName = "accounts")]
-        public ICollection<HdAccount> Accounts { get; set; }
+        public virtual ICollection<IHdAccount> Accounts { get; set; }
 
         /// <summary>
         /// Gets the first account that contains no transaction.
         /// </summary>
         /// <returns>An unused account</returns>
-        public HdAccount GetFirstUnusedAccount(IWalletStore walletStore)
+        public IHdAccount GetFirstUnusedAccount(IWalletStore walletStore)
         {
             if (this.Accounts == null)
                 return null;
 
-            List<HdAccount> unusedAccounts = this.Accounts
+            List<IHdAccount> unusedAccounts = this.Accounts
                 .Where(Wallet.NormalAccounts)
                 .Where(acc =>
                 !acc.ExternalAddresses.SelectMany(add => walletStore.GetForAddress(add.Address)).Any()
@@ -456,7 +486,7 @@ public HdAccount GetFirstUnusedAccount(IWalletStore walletStore)
         /// </summary>
         /// <param name="accountName">The name of the account to get.</param>
         /// <returns>The HD account specified by the parameter or <c>null</c> if the account does not exist.</returns>
-        public HdAccount GetAccountByName(string accountName)
+        public IHdAccount GetAccountByName(string accountName)
         {
             return this.Accounts?.SingleOrDefault(a => a.Name == accountName);
         }
@@ -475,13 +505,13 @@ public HdAccount GetAccountByName(string accountName)
         /// <param name="accountIndex">The index at which an account will be created. If left null, a new account will be created after the last used one.</param>
         /// <param name="accountName">The name of the account to be created. If left null, an account will be created according to the <see cref="AccountNamePattern"/>.</param>
         /// <returns>A new HD account.</returns>
-        public HdAccount AddNewAccount(string password, string encryptedSeed, byte[] chainCode, Network network, DateTimeOffset accountCreationTime, int? accountIndex = null, string accountName = null)
+        public IHdAccount AddNewAccount(string password, string encryptedSeed, byte[] chainCode, Network network, DateTimeOffset accountCreationTime, int? accountIndex = null, string accountName = null)
         {
             Guard.NotEmpty(password, nameof(password));
             Guard.NotEmpty(encryptedSeed, nameof(encryptedSeed));
             Guard.NotNull(chainCode, nameof(chainCode));
 
-            ICollection<HdAccount> hdAccounts = this.Accounts;
+            ICollection<IHdAccount> hdAccounts = this.Accounts;
 
             // If an account needs to be created at a specific index or with a specific name, make sure it doesn't already exist.
             if (hdAccounts.Any(a => a.Index == accountIndex || a.Name == accountName))
@@ -502,7 +532,7 @@ public HdAccount AddNewAccount(string password, string encryptedSeed, byte[] cha
                 }
             }
 
-            HdAccount newAccount = this.CreateAccount(password, encryptedSeed, chainCode, network, accountCreationTime, accountIndex.Value, accountName);
+            IHdAccount newAccount = this.CreateAccount(password, encryptedSeed, chainCode, network, accountCreationTime, accountIndex.Value, accountName);
 
             hdAccounts.Add(newAccount);
             this.Accounts = hdAccounts;
@@ -521,7 +551,7 @@ public HdAccount AddNewAccount(string password, string encryptedSeed, byte[] cha
         /// <param name="newAccountIndex">The optional account index to use.</param>
         /// <param name="newAccountName">The optional account name to use.</param>
         /// <returns>A new HD account.</returns>
-        public HdAccount CreateAccount(string password, string encryptedSeed, byte[] chainCode,
+        public IHdAccount CreateAccount(string password, string encryptedSeed, byte[] chainCode,
             Network network, DateTimeOffset accountCreationTime,
             int newAccountIndex, string newAccountName = null)
         {
@@ -553,9 +583,9 @@ public HdAccount CreateAccount(string password, string encryptedSeed, byte[] cha
         /// </summary>
         /// <param name="accountExtPubKey">The extended public key for the account.</param>
         /// <param name="accountIndex">The zero-based account index.</param>
-        public HdAccount AddNewAccount(ExtPubKey accountExtPubKey, int accountIndex, Network network, DateTimeOffset accountCreationTime)
+        public IHdAccount AddNewAccount(ExtPubKey accountExtPubKey, int accountIndex, Network network, DateTimeOffset accountCreationTime)
         {
-            ICollection<HdAccount> hdAccounts = this.Accounts.ToList();
+            ICollection<IHdAccount> hdAccounts = this.Accounts.ToList();
 
             if (hdAccounts.Any(a => a.Index == accountIndex))
             {
@@ -587,11 +617,35 @@ public HdAccount AddNewAccount(ExtPubKey accountExtPubKey, int accountIndex, Net
             return newAccount;
         }
     }
+    public class HdAccountConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            //assume we can convert to anything for now
+            return true;
+        }
 
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            List<IHdAccount> accounts = new List<IHdAccount>();
+            var list = serializer.Deserialize<List<HdAccount>>(reader);
+            foreach (var item in list)
+            {
+                accounts.Add(item);
+            }
+            return accounts;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            //use the default serialization - it works fine
+            serializer.Serialize(writer, value);
+        }
+    }
     /// <summary>
     /// An HD account's details.
     /// </summary>
-    public class HdAccount
+    public class HdAccount : IHdAccount
     {
         public HdAccount()
         {
@@ -766,7 +820,7 @@ public IEnumerable<HdAddress> GetCombinedAddresses()
         /// <param name="addressesQuantity">The number of addresses to create.</param>
         /// <param name="isChange">Whether the addresses added are change (internal) addresses or receiving (external) addresses.</param>
         /// <returns>The created addresses.</returns>
-        public IEnumerable<HdAddress> CreateAddresses(Network network, int addressesQuantity, bool isChange = false)
+        public virtual IEnumerable<HdAddress> CreateAddresses(Network network, int addressesQuantity, bool isChange = false)
         {
             ICollection<HdAddress> addresses = isChange ? this.InternalAddresses : this.ExternalAddresses;
 

From 8480e2825fc04226899cb4acf4a87a31bce93249 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:13:23 +0100
Subject: [PATCH 07/24] Integrating multisig wallet and interfaces into wallet
 manager

---
 .../WalletManager.cs                          | 158 ++++++++++++++----
 1 file changed, 121 insertions(+), 37 deletions(-)

diff --git a/src/Features/Blockcore.Features.Wallet/WalletManager.cs b/src/Features/Blockcore.Features.Wallet/WalletManager.cs
index 4444fe607..b62e7294b 100644
--- a/src/Features/Blockcore.Features.Wallet/WalletManager.cs
+++ b/src/Features/Blockcore.Features.Wallet/WalletManager.cs
@@ -55,6 +55,7 @@ public class WalletManager : IWalletManager
         /// <summary>File extension for wallet files.</summary>
         private const string WalletFileExtension = "wallet.json";
 
+        private const string WalletMultisigFileExtension = "multisigwallet.json";
         /// <summary>Timer for saving wallet files to the file system.</summary>
         private const int WalletSavetimeIntervalInMinutes = 5;
 
@@ -92,6 +93,8 @@ public class WalletManager : IWalletManager
 
         /// <summary>An object capable of storing <see cref="Wallet"/>s to the file system.</summary>
         private readonly FileStorage<Types.Wallet> fileStorage;
+        private readonly FileStorage<Types.WalletMultisig> multisigFileStorage;
+        
 
         /// <summary>The broadcast manager.</summary>
         private readonly IBroadcasterManager broadcasterManager;
@@ -164,6 +167,7 @@ public WalletManager(
             this.asyncProvider = asyncProvider;
             this.nodeLifetime = nodeLifetime;
             this.fileStorage = new FileStorage<Types.Wallet>(dataFolder.WalletPath);
+            this.multisigFileStorage = new FileStorage<Types.WalletMultisig>(dataFolder.WalletPath);
             this.signals = signals;
             this.broadcasterManager = broadcasterManager;
             this.scriptAddressReader = scriptAddressReader;
@@ -232,6 +236,8 @@ public void Start()
             // Find wallets and load them in memory.
             IEnumerable<Types.Wallet> wallets = this.fileStorage.LoadByFileExtension(WalletFileExtension);
 
+            wallets = wallets.Union(this.MultisigFileStorage.LoadByFileExtension(WalletMultisigFileExtension));
+
             foreach (Types.Wallet wallet in wallets)
             {
                 this.Load(wallet);
@@ -289,6 +295,50 @@ public void Stop()
                 disposable?.Dispose();
         }
 
+        public WalletMultisig CreateMutisigWallet(string walletName, int threashold, string[] xPubs, int coinType)
+        {
+            var multisigScheme = new MultisigScheme()
+            {
+                Threashold = threashold,
+                XPubs = xPubs
+            };
+
+            WalletMultisig wallet = new WalletMultisig(this.network);
+            wallet.Name = walletName;
+            var root = new AccountRootMultisig
+            {
+                CoinType = coinType
+            };
+            wallet.AccountsRoot.Add(root);
+
+            HdAccountMultisig account = wallet.AddNewAccount(multisigScheme, coinType, this.dateTimeProvider.GetTimeOffset());
+            IEnumerable<HdAddress> newReceivingAddresses = account.CreateAddresses(this.network, this.walletSettings.UnusedAddressesBuffer);
+            IEnumerable<HdAddress> newChangeAddresses = account.CreateAddresses(this.network, this.walletSettings.UnusedAddressesBuffer, true);
+            this.UpdateKeysLookup(wallet, newReceivingAddresses.Concat(newChangeAddresses));
+
+            // If the chain is downloaded, we set the height of the newly created wallet to it.
+            // However, if the chain is still downloading when the user creates a wallet,
+            // we wait until it is downloaded in order to set it. Otherwise, the height of the wallet will be the height of the chain at that moment.
+            if (this.ChainIndexer.IsDownloaded())
+            {
+                this.UpdateLastBlockSyncedHeight(wallet, this.ChainIndexer.Tip);
+            }
+            else
+            {
+                this.UpdateWhenChainDownloaded(new[] { wallet }, this.dateTimeProvider.GetUtcNow());
+            }
+
+            wallet.walletStore = new WalletStore(this.network, this.dataFolder, wallet);
+            this.SaveWallet(wallet);
+            this.Load(wallet);
+
+            return wallet;
+        }
+        private static string GetWalletFileName(WalletMultisig wallet)
+        {
+            return $"{wallet.Name}.multisigwallet.json";
+        }
+
         /// <inheritdoc />
         public Mnemonic CreateWallet(string password, string name, string passphrase, Mnemonic mnemonic = null, int? coinType = null)
         {
@@ -309,7 +359,7 @@ public Mnemonic CreateWallet(string password, string name, string passphrase, Mn
             // Generate multiple accounts and addresses from the get-go.
             for (int i = 0; i < WalletCreationAccountsCount; i++)
             {
-                HdAccount account = wallet.AddNewAccount(password, this.dateTimeProvider.GetTimeOffset());
+                IHdAccount account = wallet.AddNewAccount(password, this.dateTimeProvider.GetTimeOffset());
                 IEnumerable<HdAddress> newReceivingAddresses = account.CreateAddresses(this.network, this.walletSettings.UnusedAddressesBuffer);
                 IEnumerable<HdAddress> newChangeAddresses = account.CreateAddresses(this.network, this.walletSettings.UnusedAddressesBuffer, true);
                 this.UpdateKeysLookup(wallet, newReceivingAddresses.Concat(newChangeAddresses));
@@ -492,7 +542,7 @@ public virtual Types.Wallet RecoverWallet(string password, string name, string m
             // Generate multiple accounts and addresses from the get-go.
             for (int i = 0; i < WalletRecoveryAccountsCount; i++)
             {
-                HdAccount account;
+                IHdAccount account;
                 lock (this.lockObject)
                 {
                     account = wallet.AddNewAccount(password, this.dateTimeProvider.GetTimeOffset());
@@ -533,7 +583,7 @@ public Types.Wallet RecoverWallet(string name, ExtPubKey extPubKey, int accountI
             Types.Wallet wallet = this.GenerateExtPubKeyOnlyWalletFile(name, creationTime);
 
             // Generate account
-            HdAccount account;
+            IHdAccount account;
             lock (this.lockObject)
             {
                 account = wallet.AddNewAccount(extPubKey, accountIndex, this.dateTimeProvider.GetTimeOffset());
@@ -563,7 +613,7 @@ public Types.Wallet RecoverWallet(string name, ExtPubKey extPubKey, int accountI
         }
 
         /// <inheritdoc />
-        public HdAccount GetUnusedAccount(string walletName, string password)
+        public IHdAccount GetUnusedAccount(string walletName, string password)
         {
             Guard.NotEmpty(walletName, nameof(walletName));
             Guard.NotEmpty(password, nameof(password));
@@ -576,17 +626,17 @@ public HdAccount GetUnusedAccount(string walletName, string password)
                 throw new CannotAddAccountToXpubKeyWalletException("Use recover-via-extpubkey instead.");
             }
 
-            HdAccount res = this.GetUnusedAccount(wallet, password);
+            IHdAccount res = this.GetUnusedAccount(wallet, password);
             return res;
         }
 
         /// <inheritdoc />
-        public HdAccount GetUnusedAccount(Types.Wallet wallet, string password)
+        public IHdAccount GetUnusedAccount(Types.Wallet wallet, string password)
         {
             Guard.NotNull(wallet, nameof(wallet));
             Guard.NotEmpty(password, nameof(password));
 
-            HdAccount account;
+            IHdAccount account;
 
             lock (this.lockObject)
             {
@@ -621,7 +671,7 @@ public string GetExtPubKey(WalletAccountReference accountReference)
             lock (this.lockObject)
             {
                 // Get the account.
-                HdAccount account = wallet.GetAccount(accountReference.AccountName);
+                IHdAccount account = wallet.GetAccount(accountReference.AccountName);
                 if (account == null)
                     throw new WalletException($"No account with the name '{accountReference.AccountName}' could be found.");
                 extPubKey = account.ExtendedPubKey;
@@ -662,7 +712,7 @@ public IEnumerable<HdAddress> GetUnusedAddresses(WalletAccountReference accountR
             lock (this.lockObject)
             {
                 // Get the account.
-                HdAccount account = wallet.GetAccount(accountReference.AccountName);
+                IHdAccount account = wallet.GetAccount(accountReference.AccountName);
                 if (account == null)
                     throw new WalletException($"No account with the name '{accountReference.AccountName}' could be found.");
 
@@ -711,10 +761,10 @@ public IEnumerable<AccountHistory> GetHistory(string walletName, string accountN
 
             lock (this.lockObject)
             {
-                var accounts = new List<HdAccount>();
+                var accounts = new List<IHdAccount>();
                 if (!string.IsNullOrEmpty(accountName))
                 {
-                    HdAccount account = wallet.GetAccount(accountName);
+                    IHdAccount account = wallet.GetAccount(accountName);
                     if (account == null)
                         throw new WalletException($"No account with the name '{accountName}' could be found.");
 
@@ -735,7 +785,7 @@ public IEnumerable<AccountHistory> GetHistory(string walletName, string accountN
         }
 
         /// <inheritdoc />
-        public AccountHistory GetHistory(Types.Wallet wallet, HdAccount account)
+        public AccountHistory GetHistory(Types.Wallet wallet, IHdAccount account)
         {
             Guard.NotNull(account, nameof(account));
             FlatHistory[] items;
@@ -776,10 +826,10 @@ public IEnumerable<AccountHistorySlim> GetHistorySlim(string walletName, string
 
             lock (this.lockObject)
             {
-                var accounts = new List<HdAccount>();
+                var accounts = new List<IHdAccount>();
                 if (!string.IsNullOrEmpty(accountName))
                 {
-                    HdAccount account = wallet.GetAccount(accountName);
+                    IHdAccount account = wallet.GetAccount(accountName);
                     if (account == null)
                         throw new WalletException($"No account with the name '{accountName}' could be found.");
 
@@ -790,7 +840,7 @@ public IEnumerable<AccountHistorySlim> GetHistorySlim(string walletName, string
                     accounts.AddRange(wallet.GetAccounts());
                 }
 
-                foreach (HdAccount account in accounts)
+                foreach (IHdAccount account in accounts)
                 {
                     accountsHistory.Add(this.GetHistorySlim(wallet, account, skip, take));
                 }
@@ -800,7 +850,7 @@ public IEnumerable<AccountHistorySlim> GetHistorySlim(string walletName, string
         }
 
         /// <inheritdoc />
-        public AccountHistorySlim GetHistorySlim(Types.Wallet wallet, HdAccount account, int skip = 0, int take = 100)
+        public AccountHistorySlim GetHistorySlim(Types.Wallet wallet, IHdAccount account, int skip = 0, int take = 100)
         {
             Guard.NotNull(account, nameof(account));
             FlatHistorySlim[] items;
@@ -825,10 +875,10 @@ public IEnumerable<AccountBalance> GetBalances(string walletName, string account
             {
                 Types.Wallet wallet = this.GetWalletByName(walletName);
 
-                var accounts = new List<HdAccount>();
+                var accounts = new List<IHdAccount>();
                 if (!string.IsNullOrEmpty(accountName))
                 {
-                    HdAccount account = wallet.GetAccount(accountName);
+                    IHdAccount account = wallet.GetAccount(accountName);
                     if (account == null)
                         throw new WalletException($"No account with the name '{accountName}' could be found.");
 
@@ -926,13 +976,13 @@ public Types.Wallet GetWallet(string walletName)
         }
 
         /// <inheritdoc />
-        public IEnumerable<HdAccount> GetAccounts(string walletName)
+        public IEnumerable<IHdAccount> GetAccounts(string walletName)
         {
             Guard.NotEmpty(walletName, nameof(walletName));
 
             Types.Wallet wallet = this.GetWalletByName(walletName);
 
-            HdAccount[] res = null;
+            IHdAccount[] res = null;
             lock (this.lockObject)
             {
                 res = wallet.GetAccounts().ToArray();
@@ -962,6 +1012,14 @@ public int LastBlockHeight()
         /// <inheritdoc />
         public bool ContainsWallets => this.Wallets.Any();
 
+        public FileStorage<WalletMultisig> MultisigFileStorage
+        {
+            get
+            {
+                return this.multisigFileStorage;
+            }
+        }
+
         /// <summary>
         /// Gets the hash of the last block received by the wallets.
         /// </summary>
@@ -975,7 +1033,7 @@ public HashHeightPair LastReceivedBlockInfo()
                 return new HashHeightPair(chainedHeader);
             }
 
-            AccountRoot accountRoot;
+            IAccountRoot accountRoot;
             lock (this.lockObject)
             {
                 accountRoot = this.Wallets
@@ -1010,7 +1068,7 @@ public virtual IEnumerable<UnspentOutputReference> GetSpendableTransactionsInWal
         }
 
         /// <inheritdoc />
-        public IEnumerable<UnspentOutputReference> GetUnspentTransactionsInWallet(string walletName, int confirmations, Func<HdAccount, bool> accountFilter)
+        public IEnumerable<UnspentOutputReference> GetUnspentTransactionsInWallet(string walletName, int confirmations, Func<IHdAccount, bool> accountFilter)
         {
             Guard.NotEmpty(walletName, nameof(walletName));
 
@@ -1024,7 +1082,7 @@ public IEnumerable<UnspentOutputReference> GetUnspentTransactionsInWallet(string
             return res;
         }
 
-        public IEnumerable<UnspentOutputReference> GetSpendableTransactionsInWallet(string walletName, int confirmations, Func<HdAccount, bool> accountFilter)
+        public IEnumerable<UnspentOutputReference> GetSpendableTransactionsInWallet(string walletName, int confirmations, Func<IHdAccount, bool> accountFilter)
         {
             Guard.NotEmpty(walletName, nameof(walletName));
 
@@ -1047,7 +1105,7 @@ public IEnumerable<UnspentOutputReference> GetSpendableTransactionsInAccount(Wal
             UnspentOutputReference[] res = null;
             lock (this.lockObject)
             {
-                HdAccount account = wallet.GetAccount(walletAccountReference.AccountName);
+                IHdAccount account = wallet.GetAccount(walletAccountReference.AccountName);
 
                 if (account == null)
                 {
@@ -1469,14 +1527,14 @@ private void AddSpendingTransactionToWallet(Types.Wallet wallet, Transaction tra
             }
         }
 
-        public virtual void TransactionFoundInternal(Types.Wallet wallet, Script script, Func<HdAccount, bool> accountFilter = null)
+        public virtual void TransactionFoundInternal(Types.Wallet wallet, Script script, Func<IHdAccount, bool> accountFilter = null)
         {
             // An address has no knowledge whether its 'change' or not
             // so we can't use the indexer, iterate over each account
             // addresses collection to find if its change or not
             // (this can be optimized by addinga flag to the HdAddress class).
 
-            foreach (HdAccount account in wallet.GetAccounts(accountFilter ?? Types.Wallet.NormalAccounts))
+            foreach (IHdAccount account in wallet.GetAccounts(accountFilter ?? Types.Wallet.NormalAccounts))
             {
                 bool isChange;
                 if (account.ExternalAddresses.Any(address => address.ScriptPubKey == script))
@@ -1498,7 +1556,7 @@ public virtual void TransactionFoundInternal(Types.Wallet wallet, Script script,
             }
         }
 
-        private IEnumerable<HdAddress> AddAddressesToMaintainBuffer(Types.Wallet wallet, HdAccount account, bool isChange)
+        private IEnumerable<HdAddress> AddAddressesToMaintainBuffer(Types.Wallet wallet, IHdAccount account, bool isChange)
         {
             HdAddress lastUsedAddress = account.GetLastUsedAddress(wallet.walletStore, isChange);
             int lastUsedAddressIndex = lastUsedAddress?.Index ?? -1;
@@ -1533,12 +1591,38 @@ public void SaveWallet(Types.Wallet wallet)
             {
                 WalletData walletData = wallet.walletStore.GetData();
                 walletData.BlockLocator = wallet.BlockLocator;
-                AccountRoot accountRoot = wallet.AccountsRoot.Single();
+                IAccountRoot accountRoot = wallet.AccountsRoot.Single();
                 walletData.WalletTip = new HashHeightPair(accountRoot.LastBlockSyncedHash, accountRoot.LastBlockSyncedHeight.Value);
 
                 wallet.walletStore.SetData(walletData);
-
-                this.fileStorage.SaveToFile(wallet, $"{wallet.Name}.{WalletFileExtension}", new FileStorageOption { SerializeNullValues = false });
+                if (!wallet.IsMultisig)
+                {
+                    //var knownTypes = new KnownTypesBinder
+                    //{
+                    //    KnownTypes = new List<Type>
+                    //    {
+                    //        typeof(Types.Wallet),
+                    //        typeof(Types.AccountRoot),
+                    //        typeof(Types.HdAccount),
+                    //    }
+                    //};
+                    this.fileStorage.SaveToFile(wallet, $"{wallet.Name}.{WalletFileExtension}", new FileStorageOption { SerializeNullValues = false });
+                }
+                else
+                {
+                    //var knownTypes = new KnownTypesBinder
+                    //{
+                    //    KnownTypes = new List<Type>
+                    //    {
+                    //        typeof(Types.WalletMultisig),
+                    //        typeof(Types.AccountRootMultisig),
+                    //        typeof(Types.HdAccountMultisig),
+                    //    }
+                    //};
+
+                    this.multisigFileStorage.SaveToFile((WalletMultisig)wallet, $"{wallet.Name}.{WalletMultisigFileExtension}", new FileStorageOption { SerializeNullValues = false });
+                }
+                
             }
         }
 
@@ -1618,7 +1702,7 @@ private Types.Wallet GenerateWalletFile(string name, string encryptedSeed, byte[
                 ChainCode = chainCode,
                 CreationTime = creationTime ?? this.dateTimeProvider.GetTimeOffset(),
                 Network = this.network,
-                AccountsRoot = new List<AccountRoot> { new AccountRoot() { Accounts = new List<HdAccount>(), CoinType = coinType ?? this.coinType, LastBlockSyncedHeight = 0, LastBlockSyncedHash = this.network.GenesisHash } },
+                AccountsRoot = new List<IAccountRoot> { new AccountRoot() { Accounts = new List<IHdAccount>(), CoinType = coinType ?? this.coinType, LastBlockSyncedHeight = 0, LastBlockSyncedHash = this.network.GenesisHash } },
             };
 
             walletFile.walletStore = new WalletStore(this.network, this.dataFolder, walletFile);
@@ -1654,7 +1738,7 @@ private Types.Wallet GenerateExtPubKeyOnlyWalletFile(string name, DateTimeOffset
                 IsExtPubKeyWallet = true,
                 CreationTime = creationTime ?? this.dateTimeProvider.GetTimeOffset(),
                 Network = this.network,
-                AccountsRoot = new List<AccountRoot> { new AccountRoot() { Accounts = new List<HdAccount>(), CoinType = this.coinType, LastBlockSyncedHeight = 0, LastBlockSyncedHash = this.network.GenesisHash } },
+                AccountsRoot = new List<IAccountRoot> { new AccountRoot() { Accounts = new List<IHdAccount>(), CoinType = this.coinType, LastBlockSyncedHeight = 0, LastBlockSyncedHash = this.network.GenesisHash } },
             };
 
             walletFile.walletStore = new WalletStore(this.network, this.dataFolder, walletFile);
@@ -1917,8 +2001,8 @@ private void RemoveTransactionsByIds(IEnumerable<uint256> transactionsIds)
 
             lock (this.lockObject)
             {
-                IEnumerable<HdAccount> accounts = wallet.GetAccounts(a => true);
-                foreach (HdAccount account in accounts)
+                IEnumerable<IHdAccount> accounts = wallet.GetAccounts(a => true);
+                foreach (IHdAccount account in accounts)
                 {
                     foreach (HdAddress address in account.GetCombinedAddresses())
                     {
@@ -1967,7 +2051,7 @@ private void RemoveTransactionsByIds(IEnumerable<uint256> transactionsIds)
 
             lock (this.lockObject)
             {
-                IEnumerable<HdAccount> accounts = wallet.GetAccounts(Types.Wallet.AllAccounts);
+                IEnumerable<IHdAccount> accounts = wallet.GetAccounts(Types.Wallet.AllAccounts);
                 foreach (HdAccount account in accounts)
                 {
                     foreach (HdAddress address in account.GetCombinedAddresses())
@@ -2002,8 +2086,8 @@ private void RemoveTransactionsByIds(IEnumerable<uint256> transactionsIds)
 
             lock (this.lockObject)
             {
-                IEnumerable<HdAccount> accounts = wallet.GetAccounts();
-                foreach (HdAccount account in accounts)
+                IEnumerable<IHdAccount> accounts = wallet.GetAccounts();
+                foreach (IHdAccount account in accounts)
                 {
                     foreach (HdAddress address in account.GetCombinedAddresses())
                     {

From 912b8806357e045a95a043c53cfe9dfa6d5771e4 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:15:03 +0100
Subject: [PATCH 08/24] Walletmanager should prefer dealing with interface
 based objects

WalletManager should prefer dealing with interface based objects , instead of concrete classes so that multiple variations of account and etc can be used
---
 .../Interfaces/IWalletManager.cs                     | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/Features/Blockcore.Features.Wallet/Interfaces/IWalletManager.cs b/src/Features/Blockcore.Features.Wallet/Interfaces/IWalletManager.cs
index 7ae361253..34d625342 100644
--- a/src/Features/Blockcore.Features.Wallet/Interfaces/IWalletManager.cs
+++ b/src/Features/Blockcore.Features.Wallet/Interfaces/IWalletManager.cs
@@ -54,7 +54,7 @@ public interface IWalletManager
         /// This is distinct from the list of spendable transactions. A transaction can be unspent but not yet spendable due to coinbase/stake maturity, for example.
         /// </summary>
         /// <returns>A collection of unspent outputs</returns>
-        IEnumerable<UnspentOutputReference> GetUnspentTransactionsInWallet(string walletName, int confirmations, Func<HdAccount, bool> accountFilter);
+        IEnumerable<UnspentOutputReference> GetUnspentTransactionsInWallet(string walletName, int confirmations, Func<IHdAccount, bool> accountFilter);
 
         /// <summary>
         /// Helps identify UTXO's that can participate in staking.
@@ -174,7 +174,7 @@ public interface IWalletManager
         /// at index (i - 1) contains transactions.
         /// </remarks>
         /// <returns>An unused account.</returns>
-        HdAccount GetUnusedAccount(string walletName, string password);
+        IHdAccount GetUnusedAccount(string walletName, string password);
 
         /// <summary>
         /// Gets an account that contains no transactions.
@@ -186,7 +186,7 @@ public interface IWalletManager
         /// at index (i - 1) contains transactions.
         /// </remarks>
         /// <returns>An unused account.</returns>
-        HdAccount GetUnusedAccount(Types.Wallet wallet, string password);
+        IHdAccount GetUnusedAccount(Types.Wallet wallet, string password);
 
         /// <summary>
         /// Gets an address that contains no transaction.
@@ -227,7 +227,7 @@ public interface IWalletManager
         /// <param name="wallet">The wallet instance.</param>
         /// <param name="account">The account for which to get history.</param>
         /// <returns>The history for this account.</returns>
-        AccountHistory GetHistory(Types.Wallet wallet, HdAccount account);
+        AccountHistory GetHistory(Types.Wallet wallet, IHdAccount account);
 
         /// <summary>
         /// Gets the history of transactions contained in an account.
@@ -248,7 +248,7 @@ public interface IWalletManager
         /// <param name="skip">Items to skip.</param>
         /// <param name="take">Items to take.</param>
         /// <returns>The history for this account.</returns>
-        AccountHistorySlim GetHistorySlim(Types.Wallet wallet, HdAccount account, int skip = 0, int take = 100);
+        AccountHistorySlim GetHistorySlim(Types.Wallet wallet, IHdAccount account, int skip = 0, int take = 100);
 
         /// <summary>
         /// Gets the balance of transactions contained in an account.
@@ -279,7 +279,7 @@ public interface IWalletManager
         /// </summary>
         /// <param name="walletName">The name of the wallet to look into.</param>
         /// <returns></returns>
-        IEnumerable<HdAccount> GetAccounts(string walletName);
+        IEnumerable<IHdAccount> GetAccounts(string walletName);
 
         /// <summary>
         /// Gets the last block height.

From 3762664164b5587820a522684e3480757a6fe81c Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:23:28 +0100
Subject: [PATCH 09/24] Refactoring to use interfaces instead of concrete
 classes.

---
 .../Blockcore.Tests.Wallet.Common/WalletTestsHelpers.cs    | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/Tests/Blockcore.Tests.Wallet.Common/WalletTestsHelpers.cs b/src/Tests/Blockcore.Tests.Wallet.Common/WalletTestsHelpers.cs
index 8afd85c52..2a8e406bf 100644
--- a/src/Tests/Blockcore.Tests.Wallet.Common/WalletTestsHelpers.cs
+++ b/src/Tests/Blockcore.Tests.Wallet.Common/WalletTestsHelpers.cs
@@ -10,6 +10,7 @@
 using Blockcore.Features.Wallet;
 using Blockcore.Features.Wallet.Database;
 using Blockcore.Features.Wallet.Exceptions;
+using Blockcore.Features.Wallet.Interfaces;
 using Blockcore.Features.Wallet.Tests;
 using Blockcore.Features.Wallet.Types;
 using Blockcore.Networks;
@@ -149,7 +150,7 @@ public static Features.Wallet.Types.Wallet CreateWallet(string name)
             return new Features.Wallet.Types.Wallet
             {
                 Name = name,
-                AccountsRoot = new List<AccountRoot>(),
+                AccountsRoot = new List<IAccountRoot>(),
                 walletStore = new WalletMemoryStore(),
                 BlockLocator = null
             };
@@ -174,7 +175,7 @@ public static (Features.Wallet.Types.Wallet wallet, ExtKey key) GenerateBlankWal
                 Network = KnownNetworks.Main,
                 walletStore = new WalletMemoryStore(),
                 BlockLocator = new List<uint256>() { KnownNetworks.Main.GenesisHash },
-                AccountsRoot = new List<AccountRoot> { new AccountRoot() { Accounts = new List<HdAccount>(), CoinType = KnownNetworks.Main.Consensus.CoinType, LastBlockSyncedHash = KnownNetworks.Main.GenesisHash, LastBlockSyncedHeight = 0 } },
+                AccountsRoot = new List<IAccountRoot> { new AccountRoot() { Accounts = new List<IHdAccount>(), CoinType = KnownNetworks.Main.Consensus.CoinType, LastBlockSyncedHash = KnownNetworks.Main.GenesisHash, LastBlockSyncedHeight = 0 } },
             };
 
             WalletData data = walletFile.walletStore.GetData();
@@ -241,7 +242,7 @@ public static void AddAddressesToWallet(WalletManager walletManager, int count)
                     LastBlockSyncedHash = new uint256(0),
                     LastBlockSyncedHeight = 0,
                     CoinType = KnownCoinTypes.Bitcoin,
-                    Accounts = new List<HdAccount>
+                    Accounts = new List<IHdAccount>
                     {
                         new HdAccount
                         {

From e49168f34e7c1313d0bce43527e41e1e17862e13 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:28:06 +0100
Subject: [PATCH 10/24] Refactoring to use interfaces instead of concrete
 classes.

Refactoring to use interfaces instead of concrete classes.
---
 .../ColdStakingFeature.cs                     |   6 +-
 .../ColdStakingManager.cs                     |  20 ++--
 .../Api/Controllers/MiningController.cs       |   2 +-
 .../Api/Controllers/MiningRPCController.cs    |   2 +-
 .../Blockcore.Features.PoA/PoAMiner.cs        |   2 +-
 .../Api/Controllers/WalletController.cs       |  10 +-
 .../Types/FlatHistory.cs                      |   5 +-
 .../WatchOnlyWalleRPCController.cs            |   4 +-
 .../ColdStakingControllerTest.cs              |   2 +-
 .../AccountRootTest.cs                        |  11 +-
 .../Blockcore.Features.Wallet.Tests.csproj    |   1 +
 .../WalletControllerTest.cs                   |  21 ++--
 .../WalletTest.cs                             |   3 +-
 .../WalletTestBase.cs                         |   5 +-
 .../WalletTransactionHandlerTest.cs           |  10 +-
 .../Wallet/WalletOperationsTests.cs           | 113 +++++++++---------
 16 files changed, 112 insertions(+), 105 deletions(-)

diff --git a/src/Features/Blockcore.Features.ColdStaking/ColdStakingFeature.cs b/src/Features/Blockcore.Features.ColdStaking/ColdStakingFeature.cs
index f3f6e28c4..279fb9a23 100644
--- a/src/Features/Blockcore.Features.ColdStaking/ColdStakingFeature.cs
+++ b/src/Features/Blockcore.Features.ColdStaking/ColdStakingFeature.cs
@@ -164,7 +164,7 @@ private void AddComponentStats(StringBuilder benchLog)
                 {
                     // Get all the accounts, including the ones used for cold staking.
                     // TODO: change GetAccounts to accept a filter.
-                    foreach (HdAccount account in this.coldStakingManager.GetAccounts(walletName))
+                    foreach (IHdAccount account in this.coldStakingManager.GetAccounts(walletName))
                     {
                         AccountBalance accountBalance = this.coldStakingManager.GetBalances(walletName, account.Name).Single();
                         benchLog.AppendLine(($"{walletName}/{account.Name}" + ",").PadRight(LoggingConfiguration.ColumnLength + 20)
@@ -172,7 +172,7 @@ private void AddComponentStats(StringBuilder benchLog)
                                        + " Unconfirmed balance: " + accountBalance.AmountUnconfirmed.ToString());
                     }
 
-                    HdAccount coldStakingAccount = this.coldStakingManager.GetColdStakingAccount(this.coldStakingManager.GetWallet(walletName), true);
+                    IHdAccount coldStakingAccount = this.coldStakingManager.GetColdStakingAccount(this.coldStakingManager.GetWallet(walletName), true);
                     if (coldStakingAccount != null)
                     {
                         AccountBalance accountBalance = this.coldStakingManager.GetBalances(walletName, coldStakingAccount.Name).Single();
@@ -181,7 +181,7 @@ private void AddComponentStats(StringBuilder benchLog)
                                             + " Unconfirmed balance: " + accountBalance.AmountUnconfirmed.ToString());
                     }
 
-                    HdAccount hotStakingAccount = this.coldStakingManager.GetColdStakingAccount(this.coldStakingManager.GetWallet(walletName), false);
+                    IHdAccount hotStakingAccount = this.coldStakingManager.GetColdStakingAccount(this.coldStakingManager.GetWallet(walletName), false);
                     if (hotStakingAccount != null)
                     {
                         AccountBalance accountBalance = this.coldStakingManager.GetBalances(walletName, hotStakingAccount.Name).Single();
diff --git a/src/Features/Blockcore.Features.ColdStaking/ColdStakingManager.cs b/src/Features/Blockcore.Features.ColdStaking/ColdStakingManager.cs
index 37949af40..0d6c4aadb 100644
--- a/src/Features/Blockcore.Features.ColdStaking/ColdStakingManager.cs
+++ b/src/Features/Blockcore.Features.ColdStaking/ColdStakingManager.cs
@@ -183,10 +183,10 @@ public GetColdStakingInfoResponse GetColdStakingInfo(string walletName)
         /// <param name="wallet">The wallet where we wish to create the account.</param>
         /// <param name="isColdWalletAccount">Indicates whether we need the cold wallet account (versus the hot wallet account).</param>
         /// <returns>The cold staking account or <c>null</c> if the account does not exist.</returns>
-        public HdAccount GetColdStakingAccount(Wallet.Types.Wallet wallet, bool isColdWalletAccount)
+        public IHdAccount GetColdStakingAccount(Wallet.Types.Wallet wallet, bool isColdWalletAccount)
         {
             var coinType = wallet.Network.Consensus.CoinType;
-            HdAccount account = wallet.GetAccount(isColdWalletAccount ? ColdWalletAccountName : HotWalletAccountName);
+            IHdAccount account = wallet.GetAccount(isColdWalletAccount ? ColdWalletAccountName : HotWalletAccountName);
             if (account == null)
             {
                 this.logger.LogTrace("(-)[ACCOUNT_DOES_NOT_EXIST]:null");
@@ -213,11 +213,11 @@ public HdAccount GetColdStakingAccount(Wallet.Types.Wallet wallet, bool isColdWa
         /// <param name="isColdWalletAccount">Indicates whether we need the cold wallet account (versus the hot wallet account).</param>
         /// <param name="walletPassword">The wallet password which will be used to create the account.</param>
         /// <returns>The new or existing cold staking account.</returns>
-        public HdAccount GetOrCreateColdStakingAccount(string walletName, bool isColdWalletAccount, string walletPassword)
+        public IHdAccount GetOrCreateColdStakingAccount(string walletName, bool isColdWalletAccount, string walletPassword)
         {
             Wallet.Types.Wallet wallet = this.GetWalletByName(walletName);
 
-            HdAccount account = this.GetColdStakingAccount(wallet, isColdWalletAccount);
+            IHdAccount account = this.GetColdStakingAccount(wallet, isColdWalletAccount);
             if (account != null)
             {
                 this.logger.LogTrace("(-)[ACCOUNT_ALREADY_EXIST]:'{0}'", account.Name);
@@ -279,7 +279,7 @@ internal HdAddress GetFirstUnusedColdStakingAddress(string walletName, bool isCo
             Guard.NotNull(walletName, nameof(walletName));
 
             Wallet.Types.Wallet wallet = this.GetWalletByName(walletName);
-            HdAccount account = this.GetColdStakingAccount(wallet, isColdWalletAddress);
+            IHdAccount account = this.GetColdStakingAccount(wallet, isColdWalletAddress);
             if (account == null)
             {
                 this.logger.LogTrace("(-)[ACCOUNT_DOES_NOT_EXIST]:null");
@@ -340,8 +340,8 @@ internal Transaction GetColdStakingSetupTransaction(IWalletTransactionHandler wa
             Wallet.Types.Wallet wallet = this.GetWalletByName(walletName);
 
             // Get/create the cold staking accounts.
-            HdAccount coldAccount = this.GetOrCreateColdStakingAccount(walletName, true, walletPassword);
-            HdAccount hotAccount = this.GetOrCreateColdStakingAccount(walletName, false, walletPassword);
+            IHdAccount coldAccount = this.GetOrCreateColdStakingAccount(walletName, true, walletPassword);
+            IHdAccount hotAccount = this.GetOrCreateColdStakingAccount(walletName, false, walletPassword);
 
             HdAddress coldAddress = coldAccount?.ExternalAddresses.FirstOrDefault(s => s.Address == coldWalletAddress || s.Bech32Address == coldWalletAddress);
             HdAddress hotAddress = hotAccount?.ExternalAddresses.FirstOrDefault(s => s.Address == hotWalletAddress || s.Bech32Address == hotWalletAddress);
@@ -474,7 +474,7 @@ internal Transaction GetColdStakingWithdrawalTransaction(IWalletTransactionHandl
             Wallet.Types.Wallet wallet = this.GetWalletByName(walletName);
 
             // Get the cold staking account.
-            HdAccount coldAccount = this.GetColdStakingAccount(wallet, true);
+            IHdAccount coldAccount = this.GetColdStakingAccount(wallet, true);
             if (coldAccount == null)
             {
                 this.logger.LogTrace("(-)[COLDSTAKE_ACCOUNT_DOES_NOT_EXIST]");
@@ -488,7 +488,7 @@ internal Transaction GetColdStakingWithdrawalTransaction(IWalletTransactionHandl
                 throw new WalletException("You can't send the money to a cold staking cold wallet account.");
             }
 
-            HdAccount hotAccount = this.GetColdStakingAccount(wallet, false);
+            IHdAccount hotAccount = this.GetColdStakingAccount(wallet, false);
             if (hotAccount != null && hotAccount.ExternalAddresses.Concat(hotAccount.InternalAddresses).Any(s => s.Address == receivingAddress || s.Bech32Address == receivingAddress))
             {
                 this.logger.LogTrace("(-)[COLDSTAKE_INVALID_HOT_WALLET_ADDRESS_USAGE]");
@@ -599,7 +599,7 @@ public IEnumerable<UnspentOutputReference> GetSpendableTransactionsInColdWallet(
         /// </summary>
         /// <param name="script">The script (possibly a cold staking script) to check.</param>
         /// <param name="accountFilter">The account filter.</param>
-        public override void TransactionFoundInternal(Wallet.Types.Wallet wallet, Script script, Func<HdAccount, bool> accountFilter = null)
+        public override void TransactionFoundInternal(Wallet.Types.Wallet wallet, Script script, Func<IHdAccount, bool> accountFilter = null)
         {
             if (ColdStakingScriptTemplate.Instance.ExtractScriptPubKeyParameters(script, out KeyId hotPubKeyHash, out KeyId coldPubKeyHash))
             {
diff --git a/src/Features/Blockcore.Features.Miner/Api/Controllers/MiningController.cs b/src/Features/Blockcore.Features.Miner/Api/Controllers/MiningController.cs
index 4679f4894..f7212611b 100644
--- a/src/Features/Blockcore.Features.Miner/Api/Controllers/MiningController.cs
+++ b/src/Features/Blockcore.Features.Miner/Api/Controllers/MiningController.cs
@@ -145,7 +145,7 @@ internal WalletAccountReference GetAccount()
                 throw new Exception(noWalletMessage);
             }
 
-            HdAccount account = this.walletManager.GetAccounts(walletName).FirstOrDefault();
+            IHdAccount account = this.walletManager.GetAccounts(walletName).FirstOrDefault();
             if (account == null)
             {
                 this.logger.LogError(ExceptionOccurredMessage, noAccountMessage);
diff --git a/src/Features/Blockcore.Features.Miner/Api/Controllers/MiningRPCController.cs b/src/Features/Blockcore.Features.Miner/Api/Controllers/MiningRPCController.cs
index 5efaf60b0..45a64f514 100644
--- a/src/Features/Blockcore.Features.Miner/Api/Controllers/MiningRPCController.cs
+++ b/src/Features/Blockcore.Features.Miner/Api/Controllers/MiningRPCController.cs
@@ -106,7 +106,7 @@ private WalletAccountReference GetAccount()
             if (walletName == null)
                 throw new RPCServerException(RPCErrorCode.RPC_INVALID_REQUEST, "No wallet found");
 
-            HdAccount account = this.walletManager.GetAccounts(walletName).FirstOrDefault();
+            IHdAccount account = this.walletManager.GetAccounts(walletName).FirstOrDefault();
             if (account == null)
                 throw new RPCServerException(RPCErrorCode.RPC_INVALID_REQUEST, "No account found on wallet");
 
diff --git a/src/Features/Blockcore.Features.PoA/PoAMiner.cs b/src/Features/Blockcore.Features.PoA/PoAMiner.cs
index d94359317..a8c7662ea 100644
--- a/src/Features/Blockcore.Features.PoA/PoAMiner.cs
+++ b/src/Features/Blockcore.Features.PoA/PoAMiner.cs
@@ -310,7 +310,7 @@ private Script GetScriptPubKeyFromWallet()
             if (walletName == null)
                 return null;
 
-            HdAccount account = this.walletManager.GetAccounts(walletName).FirstOrDefault();
+            IHdAccount account = this.walletManager.GetAccounts(walletName).FirstOrDefault();
 
             if (account == null)
                 return null;
diff --git a/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletController.cs b/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletController.cs
index 07cfb8a02..54fd5c9cd 100644
--- a/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletController.cs
+++ b/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletController.cs
@@ -719,7 +719,7 @@ public IActionResult BuildTransaction([FromBody] BuildTransactionRequest request
                 if (!string.IsNullOrWhiteSpace(request.ChangeAddress))
                 {
                     Types.Wallet wallet = this.walletManager.GetWallet(request.WalletName);
-                    HdAccount account = wallet.GetAccount(request.AccountName);
+                    IHdAccount account = wallet.GetAccount(request.AccountName);
                     if (account == null)
                     {
                         return ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest, "Account not found.", $"No account with the name '{request.AccountName}' could be found in wallet {wallet.Name}.");
@@ -952,7 +952,7 @@ public IActionResult CreateNewAccount([FromBody] GetUnusedAccountModel request)
 
             try
             {
-                HdAccount result = this.walletManager.GetUnusedAccount(request.WalletName, request.Password);
+                IHdAccount result = this.walletManager.GetUnusedAccount(request.WalletName, request.Password);
                 return this.Json(result.Name);
             }
             catch (CannotAddAccountToXpubKeyWalletException e)
@@ -986,7 +986,7 @@ public IActionResult ListAccounts([FromQuery] ListAccountsModel request)
 
             try
             {
-                IEnumerable<HdAccount> result = this.walletManager.GetAccounts(request.WalletName);
+                IEnumerable<IHdAccount> result = this.walletManager.GetAccounts(request.WalletName);
                 return this.Json(result.Select(a => a.Name));
             }
             catch (Exception e)
@@ -1081,7 +1081,7 @@ public IActionResult GetAllAddresses([FromQuery] GetAllAddressesModel request)
             try
             {
                 Types.Wallet wallet = this.walletManager.GetWallet(request.WalletName);
-                HdAccount account = wallet.GetAccount(request.AccountName);
+                IHdAccount account = wallet.GetAccount(request.AccountName);
                 if (account == null)
                     throw new WalletException($"No account with the name '{request.AccountName}' could be found.");
 
@@ -1436,7 +1436,7 @@ public IActionResult DistributeUtxos([FromBody] DistributeUtxosRequest request)
                 var walletReference = new WalletAccountReference(request.WalletName, request.AccountName);
 
                 Types.Wallet wallet = this.walletManager.GetWallet(request.WalletName);
-                HdAccount account = wallet.GetAccount(request.AccountName);
+                IHdAccount account = wallet.GetAccount(request.AccountName);
 
                 var addresses = new List<HdAddress>();
 
diff --git a/src/Features/Blockcore.Features.Wallet/Types/FlatHistory.cs b/src/Features/Blockcore.Features.Wallet/Types/FlatHistory.cs
index 24d456c66..19ab57da0 100644
--- a/src/Features/Blockcore.Features.Wallet/Types/FlatHistory.cs
+++ b/src/Features/Blockcore.Features.Wallet/Types/FlatHistory.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using Blockcore.Features.Wallet.Database;
+using Blockcore.Features.Wallet.Interfaces;
 
 namespace Blockcore.Features.Wallet.Types
 {
@@ -8,7 +9,7 @@ public class AccountHistory
         /// <summary>
         /// The account for which the history is retrieved.
         /// </summary>
-        public HdAccount Account { get; set; }
+        public IHdAccount Account { get; set; }
 
         /// <summary>
         /// The collection of history items.
@@ -37,7 +38,7 @@ public class AccountHistorySlim
         /// <summary>
         /// The account for which the history is retrieved.
         /// </summary>
-        public HdAccount Account { get; set; }
+        public IHdAccount Account { get; set; }
 
         /// <summary>
         /// The collection of history items.
diff --git a/src/Features/Blockcore.Features.WalletWatchOnly/API/Controllers/WatchOnlyWalleRPCController.cs b/src/Features/Blockcore.Features.WalletWatchOnly/API/Controllers/WatchOnlyWalleRPCController.cs
index f0f5f3413..c5c492430 100644
--- a/src/Features/Blockcore.Features.WalletWatchOnly/API/Controllers/WatchOnlyWalleRPCController.cs
+++ b/src/Features/Blockcore.Features.WalletWatchOnly/API/Controllers/WatchOnlyWalleRPCController.cs
@@ -102,7 +102,7 @@ public ListTransactionsModel[] ListTransactions(string account = "*", int count
             }
 
             Wallet.Types.Wallet wallet = this.walletManager.GetWallet(accountReference.WalletName);
-            Func<HdAccount, bool> accountFilter = null;
+            Func<IHdAccount, bool> accountFilter = null;
             if (account == "*" || account == null)
             {
                 accountFilter = Wallet.Types.Wallet.AllAccounts;
@@ -191,7 +191,7 @@ private WalletAccountReference GetWalletAccountReference()
                 throw new RPCServerException(RPCErrorCode.RPC_INVALID_REQUEST, "No wallet found");
             }
 
-            HdAccount account = this.walletManager.GetAccounts(walletName).First();
+            IHdAccount account = this.walletManager.GetAccounts(walletName).First();
             return new WalletAccountReference(walletName, account.Name);
         }
     }
diff --git a/src/Tests/Blockcore.Features.ColdStaking.Tests/ColdStakingControllerTest.cs b/src/Tests/Blockcore.Features.ColdStaking.Tests/ColdStakingControllerTest.cs
index 2f573e5ad..e2455807d 100644
--- a/src/Tests/Blockcore.Features.ColdStaking.Tests/ColdStakingControllerTest.cs
+++ b/src/Tests/Blockcore.Features.ColdStaking.Tests/ColdStakingControllerTest.cs
@@ -852,7 +852,7 @@ public void GetColdStakingInfoOnlyConfirmAccountExistenceOnceCreated()
         private Transaction AddSpendableColdstakingTransactionToWallet(Wallet.Types.Wallet wallet, bool script = false)
         {
             // Get first unused cold staking address.
-            HdAccount account = this.coldStakingManager.GetOrCreateColdStakingAccount(wallet.Name, true, walletPassword);
+            IHdAccount account = this.coldStakingManager.GetOrCreateColdStakingAccount(wallet.Name, true, walletPassword);
             HdAddress address = this.coldStakingManager.GetFirstUnusedColdStakingAddress(wallet.Name, true);
 
             TxDestination hotPubKey = BitcoinAddress.Create(hotWalletAddress1, wallet.Network).ScriptPubKey.GetDestination(wallet.Network);
diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/AccountRootTest.cs b/src/Tests/Blockcore.Features.Wallet.Tests/AccountRootTest.cs
index c15c52b1a..9913b9f68 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/AccountRootTest.cs
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/AccountRootTest.cs
@@ -1,4 +1,5 @@
-using Blockcore.Features.Wallet.Types;
+using Blockcore.Features.Wallet.Interfaces;
+using Blockcore.Features.Wallet.Types;
 using Blockcore.Tests.Common;
 using Xunit;
 
@@ -12,7 +13,7 @@ public void GetFirstUnusedAccountWithoutAccountsReturnsNull()
             AccountRoot accountRoot = CreateAccountRoot(KnownCoinTypes.Stratis);
             WalletMemoryStore store = new WalletMemoryStore();
 
-            HdAccount result = accountRoot.GetFirstUnusedAccount(store);
+            IHdAccount result = accountRoot.GetFirstUnusedAccount(store);
 
             Assert.Null(result);
         }
@@ -22,7 +23,7 @@ public void GetFirstUnusedAccountReturnsAccountWithLowerIndexHavingNoAddresses()
         {
             AccountRoot accountRoot = CreateAccountRoot(KnownCoinTypes.Stratis);
             WalletMemoryStore store = new WalletMemoryStore();
-            HdAccount unused = CreateAccount("unused1");
+            IHdAccount unused = CreateAccount("unused1");
             unused.Index = 2;
             accountRoot.Accounts.Add(unused);
 
@@ -40,7 +41,7 @@ public void GetFirstUnusedAccountReturnsAccountWithLowerIndexHavingNoAddresses()
             used2.Index = 4;
             accountRoot.Accounts.Add(used2);
 
-            HdAccount result = accountRoot.GetFirstUnusedAccount(store);
+            IHdAccount result = accountRoot.GetFirstUnusedAccount(store);
 
             Assert.NotNull(result);
             Assert.Equal(1, result.Index);
@@ -52,7 +53,7 @@ public void GetAccountByNameWithMatchingNameReturnsAccount()
         {
             AccountRoot accountRoot = CreateAccountRootWithHdAccountHavingAddresses("Test", KnownCoinTypes.Stratis);
 
-            HdAccount result = accountRoot.GetAccountByName("Test");
+            IHdAccount result = accountRoot.GetAccountByName("Test");
 
             Assert.NotNull(result);
             Assert.Equal("Test", result.Name);
diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/Blockcore.Features.Wallet.Tests.csproj b/src/Tests/Blockcore.Features.Wallet.Tests/Blockcore.Features.Wallet.Tests.csproj
index 692639771..154798382 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/Blockcore.Features.Wallet.Tests.csproj
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/Blockcore.Features.Wallet.Tests.csproj
@@ -29,6 +29,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\Features\Blockcore.Features.Wallet\Blockcore.Features.Wallet.csproj" />
     <ProjectReference Include="..\..\Features\Blockcore.Features.RPC\Blockcore.Features.RPC.csproj" />
+    <ProjectReference Include="..\..\Networks\Blockcore.Networks.XRC\Blockcore.Networks.XRC.csproj" />
     <ProjectReference Include="..\Blockcore.Tests.Common\Blockcore.Tests.Common.csproj" />
     <ProjectReference Include="..\Blockcore.Tests.Wallet.Common\Blockcore.Tests.Wallet.Common.csproj" />
     <ProjectReference Include="..\..\Blockcore\Blockcore.csproj" />
diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/WalletControllerTest.cs b/src/Tests/Blockcore.Features.Wallet.Tests/WalletControllerTest.cs
index 91b59dfba..91bfaa167 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/WalletControllerTest.cs
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/WalletControllerTest.cs
@@ -26,6 +26,7 @@
 using NBitcoin;
 using Xunit;
 
+
 namespace Blockcore.Features.Wallet.Tests
 {
     public class WalletControllerTest : LogsTestBase
@@ -723,7 +724,7 @@ public void GetGeneralInfoSuccessfullyReturnsWalletGeneralInfoModel()
                 Name = "myWallet",
                 Network = NetworkHelpers.GetNetwork("mainnet"),
                 CreationTime = new DateTime(2017, 6, 19, 1, 1, 1),
-                AccountsRoot = new List<AccountRoot> {
+                AccountsRoot = new List<IAccountRoot> {
                     new AccountRoot()
                     {
                         CoinType = this.Network.Consensus.CoinType,
@@ -866,7 +867,7 @@ public void GetHistoryWithValidModelWithoutTransactionSpendingDetailsReturnsWall
             var account = new HdAccount { ExternalAddresses = addresses };
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             List<FlatHistory> flat = addresses.SelectMany(s => store.GetForAddress(s.Address).Select(t => new FlatHistory { Address = s, Transaction = t })).ToList();
@@ -923,7 +924,7 @@ public void GetHistoryWithValidModelWithTransactionSpendingDetailsReturnsWalletH
             var account = new HdAccount { ExternalAddresses = addresses };
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             List<FlatHistory> flat = addresses.SelectMany(s => store.GetForAddress(s.Address).Select(t => new FlatHistory { Address = s, Transaction = t })).ToList();
@@ -999,7 +1000,7 @@ public void GetHistoryWithValidModelWithFeeBelowZeroSetsFeeToZero()
             var account = new HdAccount { ExternalAddresses = addresses };
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             List<FlatHistory> flat = addresses.SelectMany(s => store.GetForAddress(s.Address).Select(t => new FlatHistory { Address = s, Transaction = t })).ToList();
@@ -1100,7 +1101,7 @@ public void GetHistoryWithDuplicateSpentTransactionsSelectsDistinctsSpentTransac
             var account = new HdAccount { ExternalAddresses = addresses };
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             List<FlatHistory> flat = addresses.SelectMany(s => store.GetForAddress(s.Address).Select(t => new FlatHistory { Address = s, Transaction = t })).ToList();
@@ -1210,7 +1211,7 @@ public void GetHistoryWithChangeAddressesShouldIncludeSpentChangeAddesses()
             var account = new HdAccount { ExternalAddresses = addresses };
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             List<FlatHistory> flat = addresses.SelectMany(s => store.GetForAddress(s.Address).Select(t => new FlatHistory { Address = s, Transaction = t })).ToList();
@@ -1613,7 +1614,7 @@ public void BuildTransactionWithChangeAddressReturnsWalletBuildTransactionModel(
             Types.Wallet wallet = WalletTestsHelpers.CreateWallet(walletName);
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> {
+                Accounts = new List<IHdAccount> {
                     new HdAccount
                     {
                         ExternalAddresses = receiveAddresses,
@@ -1659,7 +1660,7 @@ public void BuildTransactionWithChangeAddressNotInWalletReturnsBadRequest()
             Types.Wallet wallet = WalletTestsHelpers.CreateWallet(walletName);
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { new HdAccount
+                Accounts = new List<IHdAccount> { new HdAccount
                 {
                     ExternalAddresses = new List<HdAddress>(),
                     InternalAddresses = new List<HdAddress>(),
@@ -1991,7 +1992,7 @@ public void ListAccountsWithValidModelStateReturnsAccounts()
 
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount>()
+                Accounts = new List<IHdAccount>()
                 {
                     new HdAccount
                     {
@@ -2160,7 +2161,7 @@ public void GetAllAddressesWithValidModelReturnsAllAddresses()
 
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { new HdAccount
+                Accounts = new List<IHdAccount> { new HdAccount
                 {
                     ExternalAddresses = receiveAddresses,
                     InternalAddresses = changeAddresses,
diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/WalletTest.cs b/src/Tests/Blockcore.Features.Wallet.Tests/WalletTest.cs
index fb2676b01..c42e16d80 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/WalletTest.cs
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/WalletTest.cs
@@ -3,6 +3,7 @@
 using Blockcore.Consensus.ScriptInfo;
 using Blockcore.Consensus.TransactionInfo;
 using Blockcore.Features.Wallet.Database;
+using Blockcore.Features.Wallet.Interfaces;
 using Blockcore.Features.Wallet.Types;
 using Blockcore.Tests.Common;
 using NBitcoin;
@@ -17,7 +18,7 @@ public void GetAccountsWithoutAccountsReturnsEmptyList()
         {
             var wallet = new Types.Wallet();
 
-            IEnumerable<HdAccount> result = wallet.GetAccounts();
+            IEnumerable<IHdAccount> result = wallet.GetAccounts();
 
             Assert.Empty(result);
         }
diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/WalletTestBase.cs b/src/Tests/Blockcore.Features.Wallet.Tests/WalletTestBase.cs
index 94e2f5892..5472f7d43 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/WalletTestBase.cs
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/WalletTestBase.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Blockcore.Features.Wallet.Database;
+using Blockcore.Features.Wallet.Interfaces;
 using Blockcore.Features.Wallet.Types;
 using Blockcore.Tests.Common;
 using NBitcoin;
@@ -13,7 +14,7 @@ public static AccountRoot CreateAccountRoot(int coinType)
         {
             return new AccountRoot()
             {
-                Accounts = new List<HdAccount>(),
+                Accounts = new List<IHdAccount>(),
                 CoinType = coinType
             };
         }
@@ -22,7 +23,7 @@ public static AccountRoot CreateAccountRootWithHdAccountHavingAddresses(string a
         {
             return new AccountRoot()
             {
-                Accounts = new List<HdAccount> {
+                Accounts = new List<IHdAccount> {
                     new HdAccount {
                         Name = accountName,
                         InternalAddresses = new List<HdAddress>
diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/WalletTransactionHandlerTest.cs b/src/Tests/Blockcore.Features.Wallet.Tests/WalletTransactionHandlerTest.cs
index de8718c4d..bc6e825c2 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/WalletTransactionHandlerTest.cs
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/WalletTransactionHandlerTest.cs
@@ -429,7 +429,7 @@ public void Given_AnInvalidAccountIsUsed_When_GetMaximumSpendableAmountIsCalled_
             Types.Wallet wallet = WalletTestsHelpers.CreateWallet("wallet1");
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { WalletTestsHelpers.CreateAccount("account 1") }
+                Accounts = new List<IHdAccount> { WalletTestsHelpers.CreateAccount("account 1") }
             });
             walletManager.Wallets.Add(wallet);
 
@@ -466,7 +466,7 @@ public void Given_GetMaximumSpendableAmountIsCalled_When_ThereAreNoSpendableFoun
 
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             walletManager.Wallets.Add(wallet);
@@ -502,7 +502,7 @@ public void Given_GetMaximumSpendableAmountIsCalledForConfirmedTransactions_When
 
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             walletManager.Wallets.Add(wallet);
@@ -541,7 +541,7 @@ public void Given_GetMaximumSpendableAmountIsCalled_When_ThereAreNoConfirmedSpen
 
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             walletManager.Wallets.Add(wallet);
@@ -568,7 +568,7 @@ public void Given_GetMaximumSpendableAmountIsCalled_When_ThereAreNoTransactions_
             Types.Wallet wallet = WalletTestsHelpers.CreateWallet("wallet1");
             wallet.AccountsRoot.Add(new AccountRoot()
             {
-                Accounts = new List<HdAccount> { account }
+                Accounts = new List<IHdAccount> { account }
             });
 
             walletManager.Wallets.Add(wallet);
diff --git a/src/Tests/Blockcore.IntegrationTests/Wallet/WalletOperationsTests.cs b/src/Tests/Blockcore.IntegrationTests/Wallet/WalletOperationsTests.cs
index 8b2654f47..b245e75f9 100644
--- a/src/Tests/Blockcore.IntegrationTests/Wallet/WalletOperationsTests.cs
+++ b/src/Tests/Blockcore.IntegrationTests/Wallet/WalletOperationsTests.cs
@@ -9,6 +9,7 @@
 using Blockcore.Features.BlockStore.Models;
 using Blockcore.Features.Wallet;
 using Blockcore.Features.Wallet.Api.Models;
+using Blockcore.Features.Wallet.Interfaces;
 using Blockcore.Features.Wallet.Types;
 using Blockcore.IntegrationTests.Common.EnvironmentMockUpHelpers;
 using Blockcore.IntegrationTests.Common.Extensions;
@@ -103,7 +104,7 @@ public WalletOperationsTests(WalletOperationsFixture fixture)
         }
 
         [Fact]
-        public async Task GetMnemonicWithDefaultParameters()
+        public async Task GetMnemonicWithDefaultParametersAsync()
         {
             // Act.
             var mnemonic = await $"http://localhost:{this.fixture.Node.ApiPort}/api".AppendPathSegment("wallet/mnemonic").GetStringAsync();
@@ -114,7 +115,7 @@ public async Task GetMnemonicWithDefaultParameters()
         }
 
         [Fact]
-        public async Task GetMnemonicWith24FrenchWords()
+        public async Task GetMnemonicWith24FrenchWordsAsync()
         {
             // Act.
             var mnemonic = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -128,7 +129,7 @@ public async Task GetMnemonicWith24FrenchWords()
         }
 
         [Fact]
-        public async Task GetMnemonicWithUnknownLanguageFails()
+        public async Task GetMnemonicWithUnknownLanguageFailsAsync()
         {
             // Act.
             Func<Task> act = async () => await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -149,7 +150,7 @@ public async Task GetMnemonicWithUnknownLanguageFails()
         }
 
         [Fact]
-        public async Task CreateWalletWithoutMnemonic()
+        public async Task CreateWalletWithoutMnemonicAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -185,7 +186,7 @@ public async Task CreateWalletWithoutMnemonic()
             wallet.GetAccounts().Should().ContainSingle();
 
             // Check the created account.
-            HdAccount account = wallet.GetAccounts().Single();
+            IHdAccount account = wallet.GetAccounts().Single();
             account.Name.Should().Be("account 0");
             account.ExternalAddresses.Count().Should().Be(20);
             account.InternalAddresses.Count().Should().Be(20);
@@ -196,7 +197,7 @@ public async Task CreateWalletWithoutMnemonic()
         }
 
         [Fact]
-        public async Task CreateWalletWith12WordsMnemonic()
+        public async Task CreateWalletWith12WordsMnemonicAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -236,7 +237,7 @@ public async Task CreateWalletWith12WordsMnemonic()
             wallet.GetAccounts().Should().ContainSingle();
 
             // Check the created account.
-            HdAccount account = wallet.GetAccounts().Single();
+            IHdAccount account = wallet.GetAccounts().Single();
             account.Name.Should().Be("account 0");
             account.ExternalAddresses.Count().Should().Be(20);
             account.InternalAddresses.Count().Should().Be(20);
@@ -291,7 +292,7 @@ public async Task CreateWalletWith12WordsChineseMnemonicAsync()
             wallet.GetAccounts().Should().ContainSingle();
 
             // Check the created account.
-            HdAccount account = wallet.GetAccounts().Single();
+            IHdAccount account = wallet.GetAccounts().Single();
             account.Name.Should().Be("account 0");
             account.ExternalAddresses.Count().Should().Be(20);
             account.InternalAddresses.Count().Should().Be(20);
@@ -302,7 +303,7 @@ public async Task CreateWalletWith12WordsChineseMnemonicAsync()
         }
 
         [Fact]
-        public async Task CreateWalletWith24WordsMnemonic()
+        public async Task CreateWalletWith24WordsMnemonicAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -342,7 +343,7 @@ public async Task CreateWalletWith24WordsMnemonic()
             wallet.GetAccounts().Should().ContainSingle();
 
             // Check the created account.
-            HdAccount account = wallet.GetAccounts().Single();
+            IHdAccount account = wallet.GetAccounts().Single();
             account.Name.Should().Be("account 0");
             account.ExternalAddresses.Count().Should().Be(20);
             account.InternalAddresses.Count().Should().Be(20);
@@ -353,7 +354,7 @@ public async Task CreateWalletWith24WordsMnemonic()
         }
 
         [Fact]
-        public async Task CreateWalletWithPassphrase()
+        public async Task CreateWalletWithPassphraseAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -390,7 +391,7 @@ public async Task CreateWalletWithPassphrase()
             wallet.GetAccounts().Should().ContainSingle();
 
             // Check the created account.
-            HdAccount account = wallet.GetAccounts().Single();
+            IHdAccount account = wallet.GetAccounts().Single();
             account.Name.Should().Be("account 0");
             account.ExternalAddresses.Count().Should().Be(20);
             account.InternalAddresses.Count().Should().Be(20);
@@ -401,7 +402,7 @@ public async Task CreateWalletWithPassphrase()
         }
 
         [Fact]
-        public async Task CreateWalletWithoutPassword()
+        public async Task CreateWalletWithoutPasswordAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -427,7 +428,7 @@ public async Task CreateWalletWithoutPassword()
         }
 
         [Fact]
-        public async Task CompareWalletsCreatedWithAndWithoutPassphrase()
+        public async Task CompareWalletsCreatedWithAndWithoutPassphraseAsync()
         {
             // Arrange.
             string walletWithPassphraseName = "wallet-with-passphrase";
@@ -484,7 +485,7 @@ public async Task CompareWalletsCreatedWithAndWithoutPassphrase()
         }
 
         [Fact]
-        public async Task CreateWalletsWithSameMnemonicPassphraseCombinationFails()
+        public async Task CreateWalletsWithSameMnemonicPassphraseCombinationFailsAsync()
         {
             // Arrange.
             string firstWalletName = this.fixture.GetUniqueWalletName();
@@ -529,7 +530,7 @@ public async Task CreateWalletsWithSameMnemonicPassphraseCombinationFails()
         }
 
         [Fact]
-        public async Task CreateWalletsWithSameNameFails()
+        public async Task CreateWalletsWithSameNameFailsAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -569,7 +570,7 @@ public async Task CreateWalletsWithSameNameFails()
         }
 
         [Fact]
-        public async Task LoadNonExistingWallet()
+        public async Task LoadNonExistingWalletAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -594,7 +595,7 @@ public async Task LoadNonExistingWallet()
         }
 
         [Fact]
-        public async Task LoadWallet()
+        public async Task LoadWalletAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -626,7 +627,7 @@ public async Task LoadWallet()
         }
 
         [Fact]
-        public async Task LoadWalletWithWrongPassword()
+        public async Task LoadWalletWithWrongPasswordAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -674,7 +675,7 @@ public async Task LoadWalletWithWrongPassword()
         }
 
         [Fact]
-        public async Task RecoverWalletWithWrongNumberOfWordsInMnemonic()
+        public async Task RecoverWalletWithWrongNumberOfWordsInMnemonicAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -701,7 +702,7 @@ public async Task RecoverWalletWithWrongNumberOfWordsInMnemonic()
         }
 
         [Fact]
-        public async Task RecoverWalletWithoutMnemonic()
+        public async Task RecoverWalletWithoutMnemonicAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -727,7 +728,7 @@ public async Task RecoverWalletWithoutMnemonic()
         }
 
         [Fact]
-        public async Task RecoverWalletWithoutPassword()
+        public async Task RecoverWalletWithoutPasswordAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -753,7 +754,7 @@ public async Task RecoverWalletWithoutPassword()
         }
 
         [Fact]
-        public async Task RecoverWalletWithPassphrase()
+        public async Task RecoverWalletWithPassphraseAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -787,7 +788,7 @@ public async Task RecoverWalletWithPassphrase()
             wallet.GetAccounts().Should().ContainSingle();
 
             // Check the created account.
-            HdAccount account = wallet.GetAccounts().Single();
+            IHdAccount account = wallet.GetAccounts().Single();
             account.Name.Should().Be("account 0");
             account.ExternalAddresses.Count().Should().Be(20);
             account.InternalAddresses.Count().Should().Be(20);
@@ -798,7 +799,7 @@ public async Task RecoverWalletWithPassphrase()
         }
 
         [Fact]
-        public async Task RecoverWalletWithoutPassphrase()
+        public async Task RecoverWalletWithoutPassphraseAsync()
         {
             // Arrange.
             string walletName = this.fixture.GetUniqueWalletName();
@@ -832,7 +833,7 @@ public async Task RecoverWalletWithoutPassphrase()
             wallet.GetAccounts().Should().ContainSingle();
 
             // Check the created account.
-            HdAccount account = wallet.GetAccounts().Single();
+            IHdAccount account = wallet.GetAccounts().Single();
             account.Name.Should().Be("account 0");
             account.ExternalAddresses.Count().Should().Be(20);
             account.InternalAddresses.Count().Should().Be(20);
@@ -843,7 +844,7 @@ public async Task RecoverWalletWithoutPassphrase()
         }
 
         [Fact]
-        public async Task RecoverWalletWithSameMnemonicPassphraseAsExistingWalletFails()
+        public async Task RecoverWalletWithSameMnemonicPassphraseAsExistingWalletFailsAsync()
         {
             // Arrange.
             string firstWalletName = this.fixture.GetUniqueWalletName();
@@ -891,7 +892,7 @@ public async Task RecoverWalletWithSameMnemonicPassphraseAsExistingWalletFails()
         }
 
         [Fact]
-        public async Task CheckBalancesInWallet()
+        public async Task CheckBalancesInWalletAsync()
         {
             // Act.
             var response = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -911,7 +912,7 @@ public async Task CheckBalancesInWallet()
         }
 
         [Fact]
-        public async Task CheckBalancesWhenNoWalletWithThisNameExists()
+        public async Task CheckBalancesWhenNoWalletWithThisNameExistsAsync()
         {
             // Arrange.
             string walletName = "no-such-wallet";
@@ -935,7 +936,7 @@ public async Task CheckBalancesWhenNoWalletWithThisNameExists()
         }
 
         [Fact]
-        public async Task CheckBalancesWhenNoAccountWithThisNameExists()
+        public async Task CheckBalancesWhenNoAccountWithThisNameExistsAsync()
         {
             // Act.
             Func<Task> act = async () => await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -956,7 +957,7 @@ public async Task CheckBalancesWhenNoAccountWithThisNameExists()
         }
 
         [Fact]
-        public async Task FundsReceivedByAddress()
+        public async Task FundsReceivedByAddressAsync()
         {
             // Arrange.
             string address = "TRCT9QP3ipb6zCvW15yKoEtaU418UaKVE2";
@@ -977,7 +978,7 @@ public async Task FundsReceivedByAddress()
         }
 
         [Fact]
-        public async Task FundsReceivedByAddressWhenNoSuchAddressExists()
+        public async Task FundsReceivedByAddressWhenNoSuchAddressExistsAsync()
         {
             // Arrange.
             string address = "TX725W9ngnnoNuXX6mxvx5iHwS9VEuTa4s";
@@ -1001,7 +1002,7 @@ public async Task FundsReceivedByAddressWhenNoSuchAddressExists()
         }
 
         [Fact]
-        public async Task CheckMaxBalancesInWallet()
+        public async Task CheckMaxBalancesInWalletAsync()
         {
             // Act.
             var balanceResponse = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1022,7 +1023,7 @@ public async Task CheckMaxBalancesInWallet()
         }
 
         [Fact]
-        public async Task CheckMaxBalancesInWalletWhenNoWalletWithThisNameExists()
+        public async Task CheckMaxBalancesInWalletWhenNoWalletWithThisNameExistsAsync()
         {
             // Arrange.
             string walletName = "no-such-wallet";
@@ -1046,7 +1047,7 @@ public async Task CheckMaxBalancesInWalletWhenNoWalletWithThisNameExists()
         }
 
         [Fact]
-        public async Task GetExtPubKeyWhenNoAccountWithThisNameExists()
+        public async Task GetExtPubKeyWhenNoAccountWithThisNameExistsAsync()
         {
             // Arrange.
             string accountName = "account 1222";
@@ -1070,7 +1071,7 @@ public async Task GetExtPubKeyWhenNoAccountWithThisNameExists()
         }
 
         [Fact]
-        public async Task GetExtPubKeyForAccount()
+        public async Task GetExtPubKeyForAccountAsync()
         {
             // Arrange.
             string accountName = "account 0";
@@ -1086,7 +1087,7 @@ public async Task GetExtPubKeyForAccount()
         }
 
         [Fact]
-        public async Task GetAccountsInWallet()
+        public async Task GetAccountsInWalletAsync()
         {
             // Act.
             IEnumerable<string> accountsNames = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1102,7 +1103,7 @@ public async Task GetAccountsInWallet()
         }
 
         [Fact]
-        public async Task GetAccountsInWalletWhenNoWalletWithThisNameExists()
+        public async Task GetAccountsInWalletWhenNoWalletWithThisNameExistsAsync()
         {
             // Arrange.
             string walletName = "no-such-wallet";
@@ -1126,7 +1127,7 @@ public async Task GetAccountsInWalletWhenNoWalletWithThisNameExists()
         }
 
         [Fact]
-        public async Task GetAddressesInAccount()
+        public async Task GetAddressesInAccountAsync()
         {
             // Act.
             AddressesModel addressesModel = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1141,7 +1142,7 @@ public async Task GetAddressesInAccount()
         }
 
         [Fact]
-        public async Task GetAddressesInAccountWhenNoWalletWithThisNameExists()
+        public async Task GetAddressesInAccountWhenNoWalletWithThisNameExistsAsync()
         {
             // Arrange.
             string walletName = "no-such-wallet";
@@ -1165,7 +1166,7 @@ public async Task GetAddressesInAccountWhenNoWalletWithThisNameExists()
         }
 
         [Fact]
-        public async Task GetAddressesInAccountWhenNoAccountWithThisNameExists()
+        public async Task GetAddressesInAccountWhenNoAccountWithThisNameExistsAsync()
         {
             // Arrange.
             string accountName = "account 122";
@@ -1188,7 +1189,7 @@ public async Task GetAddressesInAccountWhenNoAccountWithThisNameExists()
         }
 
         [Fact]
-        public async Task GetSingleUnusedAddressesInAccount()
+        public async Task GetSingleUnusedAddressesInAccountAsync()
         {
             // Act.
             IEnumerable<string> unusedaddresses = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1204,7 +1205,7 @@ public async Task GetSingleUnusedAddressesInAccount()
         }
 
         [Fact]
-        public async Task GetWalletGeneralInfo()
+        public async Task GetWalletGeneralInfoAsync()
         {
             // Act.
             WalletGeneralInfoModel generalInfoModel = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1222,7 +1223,7 @@ public async Task GetWalletGeneralInfo()
         }
 
         [Fact]
-        public async Task BuildTransactionFromWallet()
+        public async Task BuildTransactionFromWalletAsync()
         {
             // Arrange.
             var address = new Key().PubKey.GetAddress(this.fixture.Node.FullNode.Network).ToString();
@@ -1250,7 +1251,7 @@ public async Task BuildTransactionFromWallet()
         }
 
         [Fact]
-        public async Task BuildTransactionWithSelectedInputs()
+        public async Task BuildTransactionWithSelectedInputsAsync()
         {
             // Arrange.
             var address = new Key().PubKey.GetAddress(this.fixture.Node.FullNode.Network).ToString();
@@ -1290,7 +1291,7 @@ public async Task BuildTransactionWithSelectedInputs()
         }
 
         [Fact]
-        public async Task BuildTransactionWithMultipleRecipients()
+        public async Task BuildTransactionWithMultipleRecipientsAsync()
         {
             // Arrange.
             var address1 = new Key().PubKey.GetAddress(this.fixture.Node.FullNode.Network).ToString();
@@ -1323,7 +1324,7 @@ public async Task BuildTransactionWithMultipleRecipients()
         }
 
         [Fact]
-        public async Task BuildTransactionFailsWhenUsingFeeAmountAndFeeType()
+        public async Task BuildTransactionFailsWhenUsingFeeAmountAndFeeTypeAsync()
         {
             // Arrange.
             var address = new Key().PubKey.GetAddress(this.fixture.Node.FullNode.Network).ToString();
@@ -1358,7 +1359,7 @@ public async Task BuildTransactionFailsWhenUsingFeeAmountAndFeeType()
         }
 
         [Fact]
-        public async Task BuildTransactionFailsWhenNoFeeMethodSpecified()
+        public async Task BuildTransactionFailsWhenNoFeeMethodSpecifiedAsync()
         {
             // Arrange.
             var address = new Key().PubKey.GetAddress(this.fixture.Node.FullNode.Network).ToString();
@@ -1455,7 +1456,7 @@ public async Task EstimateFeeWithOpReturnAsync()
         }
 
         [Fact]
-        public async Task GetWalletGeneralInfoWhenNoWalletWithThisNameExists()
+        public async Task GetWalletGeneralInfoWhenNoWalletWithThisNameExistsAsync()
         {
             // Arrange.
             string walletName = "no-such-wallet";
@@ -1479,7 +1480,7 @@ public async Task GetWalletGeneralInfoWhenNoWalletWithThisNameExists()
         }
 
         [Fact]
-        public async Task GetWalletFiles()
+        public async Task GetWalletFilesAsync()
         {
             // Act.
             WalletFileModel walletFileModel = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1493,7 +1494,7 @@ public async Task GetWalletFiles()
         }
 
         [Fact]
-        public async Task SignMessage()
+        public async Task SignMessageAsync()
         {
             // Act.
             SignMessageResult signatureResult = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1515,7 +1516,7 @@ public async Task SignMessage()
         }
 
         [Fact]
-        public async Task VerifyValidSignature()
+        public async Task VerifyValidSignatureAsync()
         {
             // Act.
             bool verifyMessageResult = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1533,7 +1534,7 @@ public async Task VerifyValidSignature()
         }
 
         [Fact]
-        public async Task VerifyInvalidSignature()
+        public async Task VerifyInvalidSignatureAsync()
         {
             // Act.
             bool verifyMessageResult = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1551,7 +1552,7 @@ public async Task VerifyInvalidSignature()
         }
 
         [Fact]
-        public async Task VerifyMessageWithInvalidAddress()
+        public async Task VerifyMessageWithInvalidAddressAsync()
         {
             // Act.
             bool verifyMessageResult = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1569,7 +1570,7 @@ public async Task VerifyMessageWithInvalidAddress()
         }
 
         [Fact]
-        public async Task VerifyMessageWithInvalidMessage()
+        public async Task VerifyMessageWithInvalidMessageAsync()
         {
             // Act.
             bool verifyMessageResult = await $"http://localhost:{this.fixture.Node.ApiPort}/api"
@@ -1587,7 +1588,7 @@ public async Task VerifyMessageWithInvalidMessage()
         }
 
         [Fact]
-        public async Task VerifyMessageWithAllInvalid()
+        public async Task VerifyMessageWithAllInvalidAsync()
         {
             // Act.
             bool verifyMessageResult = await $"http://localhost:{this.fixture.Node.ApiPort}/api"

From 6f36959e72013ce72d218da4d1d7ce4ea6e544b8 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:29:03 +0100
Subject: [PATCH 11/24] Refactoring to use interfaces instead of concrete
 classes

Added multisig wallet creation test
---
 .../WalletManagerTest.cs                      | 198 ++++++++++++++----
 1 file changed, 162 insertions(+), 36 deletions(-)

diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/WalletManagerTest.cs b/src/Tests/Blockcore.Features.Wallet.Tests/WalletManagerTest.cs
index 58a88d52d..20a7f61b6 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/WalletManagerTest.cs
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/WalletManagerTest.cs
@@ -17,6 +17,7 @@
 using Blockcore.Features.Wallet.Types;
 using Blockcore.Interfaces;
 using Blockcore.Networks;
+using Blockcore.Networks.XRC;
 using Blockcore.Tests.Common;
 using Blockcore.Tests.Common.Logging;
 using Blockcore.Tests.Wallet.Common;
@@ -26,7 +27,7 @@
 using Microsoft.Extensions.Logging;
 using Moq;
 using NBitcoin;
-using NBitcoin.Protocol;
+using NBitcoin.DataEncoders;
 using Newtonsoft.Json;
 using NLog.Time;
 using Xunit;
@@ -44,6 +45,131 @@ public WalletManagerTest(WalletFixture walletFixture)
             this.walletFixture = walletFixture;
         }
 
+        /// <summary>
+        /// This is more of an integration test to verify fields are filled correctly. This is what I could confirm.
+        /// </summary>
+        [Fact]
+        public void CreateMultisigXRCWallet()
+        {
+            DataFolder dataFolder = CreateDataFolder(this);
+            this.Network = new XRCMain();
+            var chain = new ChainIndexer(this.Network);
+            uint nonce = RandomUtils.GetUInt32();
+            var block = this.Network.CreateBlock();
+            block.AddTransaction(new Transaction());
+            block.UpdateMerkleRoot();
+            block.Header.HashPrevBlock = chain.Genesis.HashBlock;
+            block.Header.Nonce = nonce;
+            block.Header.BlockTime = DateTimeOffset.Now;
+            chain.SetTip(block.Header);
+
+            var walletManager = new WalletManager(this.LoggerFactory.Object, this.Network, chain, new WalletSettings(NodeSettings.Default(this.Network)),
+                dataFolder, new Mock<IWalletFeePolicy>().Object, new Mock<IAsyncProvider>().Object, new NodeLifetime(), DateTimeProvider.Default, new ScriptAddressReader());
+
+            var xPubs = new string[]
+            {
+                "xpub661MyMwAqRbcFK4g9bHwLNYLmy4JxSFkKNRURL3hJqVYLoZ318eHmEKjMbFxbgDiaMycDk4oixtRkHKgbopRzukzimmyzAb2aEVfAEeJPxt",
+                "xpub661MyMwAqRbcFVViGz3WGiaYgzsKWKXYduJZ8oR4tnnaRLp2QXMUf5P9Yq6CpJ8zuddutUFyrTkMECqqa1UyjnegVpoiYbcqpJfSCP9GcmG",
+                "xpub661MyMwAqRbcFYCYnw23jLqPAHMvCfmLeKkmDSLGy6nGpVtJvN9EDoR2qdz8fmvkV8sSa1ZT7j8oyfBgjHKX2nGnESLqSndrM2gJ6TGcXrU",
+            };
+
+            var recieveRedeemScripts = new string[]
+            {
+                "522102134708a8b6df4908a73041d97feb75d0b2706710e8dacad9107d26e13c1fcc5521027a4fdc628e20e430e525b098b4fa3ef888765d03651b4d78ff795438ac458dcb210305615df6ea6f4370f2ca4b09f0139523cfca72f0df7588d85eced64b51e25e0053ae",
+                "522102e8bf4c7f1a483ff6e42fda3a4b99acf35f53d1dc2e19b41428d693d86cc7457b21037a5ba1a77965d5c3212a3c596ff05843c098b7f1fd0a302a505fb26d0b7cbe1a2103f3a2ed18c90dffad6535950de5d22677d9c7f88d6b61e221544fd8d26184693153ae",
+                "52210225a49e0cc70ee1a2aa63ae98f12fe644069d0b591c77967394a53709dd0730782102ab2bb7280689df3167c2fe80cd0abd3c3cf1ba769b235ed5155b18a0b2fa9e192103c01f3c9b8bdff0329f9e05a61cf4b5d50ceddafc39300d74411c8f2a46b91cbb53ae",
+                "522102db7982444aa7218263e8e075b50f7fa59b14f1288b358ad677ff7bf1b2aaa8d121039e67696312bb838d755efd221734349fa5db59a4385d8241460a1ba3c2e62bfe2103c71608f27b41be9d6822fd50f31bfff0ce691a16ba760ed821801a07512d965653ae",
+                "5221026135f28080e9e91f693e7458a52a6727b8130d8f689d3d58fb25eee70f099f2021035c604fe5ec14740bd2fbca5913054730c5fc2245f45392f3fcbfdd30f939b8b32103e33eb2a622d8dbb420b88b836841eb7d6b39d5637f718610df566fa3c50d297d53ae",
+            };
+
+            var changeRedeemScripts = new string[]
+            {
+                "52210230b1265c672328e722e06bf5395edb3dc77f27064de1dde9ee55771d59091b0521036feaf4e275bf6be6c7d4ec11969ea7f1c2e51a1b8e364b5450ab6055caf4ed462103b6bdb98fce45ae9cc0ac84359edc870ee9c37ab40961bfe3397e98ce6cf1e75c53ae",
+                "522102923652c9b6220b61a06b1907c700679d07a6895c35cfd612e7cb32f7b485fe622102f32b590744b70c0054b36736bc4fb7711b6126d33784537a50075aa5d7e0aaa5210314bc014000fd5f4469deaaeedc32da2e8aafc4d0519c16c581f184be78211a7c53ae",
+                "5221028de4dafd843231bc1b314192af8dcac9e974fe7c57171fbc3dcdeafa23be68312102c3d99d45c9ce81afc3f7cf1affe0f46e4675fd4feb822347f063b40391c0e74b2103861b41d6d67c19c0676f0906f0e6f74eb36a16fb72b209279fdea2962d7bc36753ae",
+                "52210215adb25ce0663b62afa80d3f9e4c212916181538b3cbb27b8d506577a77730d521032f1598232775df6008a3a36fcd20b630345fd087d648c7b37f85d470386227872103e940b74d39ee703bf87035ae21d76b4e560e3525a1fc1120d49507abe0f131ed53ae",
+                "52210238e487536141e85e96d5fce77227951c53704b6288e8a85bc2de8d61bae3f830210296fcf49b9ee68c52e977ece9e8f3a245675d5fe8bdd766ddd73f55b3f9d534ae2103bb37235320477cefa081bb01c8952538607b6ef146b60750610520e66c35e30453ae",
+            };
+
+            // create the wallet
+            WalletMultisig expectedWallet = walletManager.CreateMutisigWallet("mywallet", 2, xPubs, 10291);
+
+            // assert it has saved it to disk and has been created correctly.
+            var actualWallet = walletManager.MultisigFileStorage.LoadByFileName("mywallet.multisigwallet.json");
+
+            Assert.Equal("mywallet", expectedWallet.Name);
+            Assert.Equal(this.Network, expectedWallet.Network);
+
+            Assert.Equal(expectedWallet.Name, actualWallet.Name);
+            Assert.Equal(expectedWallet.Network, actualWallet.Network);
+            Assert.True(actualWallet.IsMultisig);
+            Assert.Equal(actualWallet.EncryptedSeed, string.Empty);
+            Assert.Equal(expectedWallet.ChainCode, actualWallet.ChainCode);
+
+            Assert.Equal(1, expectedWallet.AccountsRoot.Count);
+            Assert.Equal(1, actualWallet.AccountsRoot.Count);
+
+            for (var i = 0; i < expectedWallet.AccountsRoot.Count; i++)
+            {
+                Assert.Equal(10291, expectedWallet.AccountsRoot.FirstOrDefault().CoinType);
+                Assert.Equal(1, expectedWallet.AccountsRoot.FirstOrDefault().LastBlockSyncedHeight);
+                Assert.Equal(block.GetHash(), expectedWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHash);
+
+                Assert.Equal(expectedWallet.AccountsRoot.ElementAt(i).CoinType, actualWallet.AccountsRoot.ElementAt(i).CoinType);
+                
+                // blockcore wallet does not serialize these, because this has explicit json ignore messages.
+                Assert.Null(actualWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHash);
+                Assert.Null(actualWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHeight);
+
+                var accountRoot = actualWallet.AccountsRoot.ElementAt(i);
+                Assert.Equal(1, accountRoot.Accounts.Count);
+
+                for (var j = 0; j < accountRoot.Accounts.Count; j++)
+                {
+                    var actualAccount = accountRoot.Accounts.ElementAt(j);
+                    Assert.Equal($"account {j}", actualAccount.Name);
+                    Assert.Equal(j, actualAccount.Index);
+                    Assert.Equal($"m/45'/10291'/{j}'", actualAccount.HdPath);
+
+
+                    Assert.Equal("N/A", actualAccount.ExtendedPubKey);
+
+                    Assert.Equal(20, actualAccount.InternalAddresses.Count);
+
+                    for (var k = 0; k < 5; k++)
+                    {
+                        var actualAddress = actualAccount.InternalAddresses.ElementAt(k);
+                        Script expectedAddressPubKey = Script.FromBytesUnsafe(Encoders.Hex.DecodeData(changeRedeemScripts[k]));
+                        var expectedAddress = expectedAddressPubKey.Hash.GetAddress(expectedWallet.Network);
+                        Assert.Equal(k, actualAddress.Index);
+                        Assert.Equal(expectedAddress.ScriptPubKey, actualAddress.ScriptPubKey);
+                        Assert.Equal(expectedAddress.ToString(), actualAddress.Address);
+                        Assert.Equal(expectedAddressPubKey, actualAddress.Pubkey);
+                        Assert.Equal($"m/45'/10291'/{j}'/1/{k}", actualAddress.HdPath);
+                        //Assert.Equal(0, actualAddress.Transactions.Count);
+                    }
+
+                    Assert.Equal(20, actualAccount.ExternalAddresses.Count);
+                    for (var l = 0; l < 5; l++)
+                    {
+                        var actualAddress = actualAccount.ExternalAddresses.ElementAt(l);
+                        Script expectedAddressPubKey = Script.FromBytesUnsafe(Encoders.Hex.DecodeData(recieveRedeemScripts[l]));
+                        var expectedAddress = expectedAddressPubKey.Hash.GetAddress(expectedWallet.Network);
+                        Assert.Equal(l, actualAddress.Index);
+                        Assert.Equal(expectedAddress.ScriptPubKey, actualAddress.ScriptPubKey);
+                        Assert.Equal(expectedAddress.ToString(), actualAddress.Address);
+                        Assert.Equal(expectedAddressPubKey, actualAddress.Pubkey);
+                        Assert.Equal($"m/45'/10291'/{j}'/0/{l}", actualAddress.HdPath);
+                        //Assert.Equal(0, actualAddress.Transactions.Count);
+                    }
+                }
+            }
+
+            Assert.Equal(2, expectedWallet.BlockLocator.Count);
+            //blockore wallets have explicit jsonignore directives at time of writing this
+            Assert.Null(actualWallet.BlockLocator);
+        }
+
         /// <summary>
         /// This is more of an integration test to verify fields are filled correctly. This is what I could confirm.
         /// </summary>
@@ -93,12 +219,12 @@ public void CreateWalletWithoutPassphraseOrMnemonicCreatesWalletUsingPassword()
 
                 Assert.Equal(expectedWallet.AccountsRoot.ElementAt(i).CoinType, actualWallet.AccountsRoot.ElementAt(i).CoinType);
 
-                AccountRoot accountRoot = actualWallet.AccountsRoot.ElementAt(i);
+                IAccountRoot accountRoot = actualWallet.AccountsRoot.ElementAt(i);
                 Assert.Equal(1, accountRoot.Accounts.Count);
 
                 for (int j = 0; j < accountRoot.Accounts.Count; j++)
                 {
-                    HdAccount actualAccount = accountRoot.Accounts.ElementAt(j);
+                    IHdAccount actualAccount = accountRoot.Accounts.ElementAt(j);
                     Assert.Equal($"account {j}", actualAccount.Name);
                     Assert.Equal(j, actualAccount.Index);
                     Assert.Equal($"m/44'/105'/{j}'", actualAccount.HdPath);
@@ -188,12 +314,12 @@ public void CreateWalletWithPasswordAndPassphraseCreatesWalletUsingPasswordAndPa
 
                 Assert.Equal(expectedWallet.AccountsRoot.ElementAt(i).CoinType, actualWallet.AccountsRoot.ElementAt(i).CoinType);
 
-                AccountRoot accountRoot = actualWallet.AccountsRoot.ElementAt(i);
+                IAccountRoot accountRoot = actualWallet.AccountsRoot.ElementAt(i);
                 Assert.Equal(1, accountRoot.Accounts.Count);
 
                 for (int j = 0; j < accountRoot.Accounts.Count; j++)
                 {
-                    HdAccount actualAccount = accountRoot.Accounts.ElementAt(j);
+                    IHdAccount actualAccount = accountRoot.Accounts.ElementAt(j);
                     Assert.Equal($"account {j}", actualAccount.Name);
                     Assert.Equal(j, actualAccount.Index);
                     Assert.Equal($"m/44'/105'/{j}'", actualAccount.HdPath);
@@ -271,7 +397,7 @@ public void CreateWalletWithWalletSetting100UnusedAddressBufferCreates100Address
 
             walletManager.CreateWallet("test", "mywallet", "this is my magic passphrase", new Mnemonic(Wordlist.English, WordCount.Eighteen));
 
-            HdAccount hdAccount = walletManager.Wallets.Single().AccountsRoot.Single().Accounts.Single();
+            IHdAccount hdAccount = walletManager.Wallets.Single().AccountsRoot.Single().Accounts.Single();
 
             Assert.Equal(100, hdAccount.ExternalAddresses.Count);
             Assert.Equal(100, hdAccount.InternalAddresses.Count);
@@ -380,16 +506,16 @@ public void RecoverWalletWithEqualInputAsExistingWalletRecoversWallet()
                 Assert.Equal(expectedWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHeight, recoveredWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHeight);
                 Assert.Equal(expectedWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHash, recoveredWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHash);
 
-                AccountRoot recoveredAccountRoot = recoveredWallet.AccountsRoot.ElementAt(i);
-                AccountRoot expectedAccountRoot = expectedWallet.AccountsRoot.ElementAt(i);
+                IAccountRoot recoveredAccountRoot = recoveredWallet.AccountsRoot.ElementAt(i);
+                IAccountRoot expectedAccountRoot = expectedWallet.AccountsRoot.ElementAt(i);
 
                 Assert.Equal(1, recoveredAccountRoot.Accounts.Count);
                 Assert.Equal(1, expectedAccountRoot.Accounts.Count);
 
                 for (int j = 0; j < expectedAccountRoot.Accounts.Count; j++)
                 {
-                    HdAccount expectedAccount = expectedAccountRoot.Accounts.ElementAt(j);
-                    HdAccount recoveredAccount = recoveredAccountRoot.Accounts.ElementAt(j);
+                    IHdAccount expectedAccount = expectedAccountRoot.Accounts.ElementAt(j);
+                    IHdAccount recoveredAccount = recoveredAccountRoot.Accounts.ElementAt(j);
                     Assert.Equal(expectedAccount.Name, recoveredAccount.Name);
                     Assert.Equal(expectedAccount.Index, recoveredAccount.Index);
                     Assert.Equal(expectedAccount.HdPath, recoveredAccount.HdPath);
@@ -463,16 +589,16 @@ public void RecoverWalletOnlyWithPasswordWalletRecoversWallet()
                 Assert.Equal(expectedWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHeight, recoveredWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHeight);
                 Assert.Equal(expectedWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHash, recoveredWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHash);
 
-                AccountRoot recoveredAccountRoot = recoveredWallet.AccountsRoot.ElementAt(i);
-                AccountRoot expectedAccountRoot = expectedWallet.AccountsRoot.ElementAt(i);
+                IAccountRoot recoveredAccountRoot = recoveredWallet.AccountsRoot.ElementAt(i);
+                IAccountRoot expectedAccountRoot = expectedWallet.AccountsRoot.ElementAt(i);
 
                 Assert.Equal(1, recoveredAccountRoot.Accounts.Count);
                 Assert.Equal(1, expectedAccountRoot.Accounts.Count);
 
                 for (int j = 0; j < expectedAccountRoot.Accounts.Count; j++)
                 {
-                    HdAccount expectedAccount = expectedAccountRoot.Accounts.ElementAt(j);
-                    HdAccount recoveredAccount = recoveredAccountRoot.Accounts.ElementAt(j);
+                    IHdAccount expectedAccount = expectedAccountRoot.Accounts.ElementAt(j);
+                    IHdAccount recoveredAccount = recoveredAccountRoot.Accounts.ElementAt(j);
                     Assert.Equal(expectedAccount.Name, recoveredAccount.Name);
                     Assert.Equal(expectedAccount.Index, recoveredAccount.Index);
                     Assert.Equal(expectedAccount.HdPath, recoveredAccount.HdPath);
@@ -556,7 +682,7 @@ public void GetUnusedAccountUsingWalletNameWithExistingAccountReturnsUnusedAccou
             wallet.AccountsRoot.ElementAt(0).Accounts.Add(new HdAccount { Name = "unused" });
             walletManager.Wallets.Add(wallet);
 
-            HdAccount result = walletManager.GetUnusedAccount("testWallet", "password");
+            IHdAccount result = walletManager.GetUnusedAccount("testWallet", "password");
 
             Assert.Equal("unused", result.Name);
             Assert.False(File.Exists(Path.Combine(dataFolder.WalletPath + $"/testWallet.wallet.json")));
@@ -573,7 +699,7 @@ public void GetUnusedAccountUsingWalletNameWithoutUnusedAccountsCreatesAccountAn
             wallet.AccountsRoot.ElementAt(0).Accounts.Clear();
             walletManager.Wallets.Add(wallet);
 
-            HdAccount result = walletManager.GetUnusedAccount("testWallet", "password");
+            IHdAccount result = walletManager.GetUnusedAccount("testWallet", "password");
 
             Assert.Equal("account 0", result.Name);
 
@@ -594,7 +720,7 @@ public void GetUnusedAccountUsingWalletWithExistingAccountReturnsUnusedAccountIf
             wallet.AccountsRoot.ElementAt(0).Accounts.Add(new HdAccount { Name = "unused" });
             walletManager.Wallets.Add(wallet);
 
-            HdAccount result = walletManager.GetUnusedAccount(wallet, "password");
+            IHdAccount result = walletManager.GetUnusedAccount(wallet, "password");
 
             Assert.Equal("unused", result.Name);
             Assert.False(File.Exists(Path.Combine(dataFolder.WalletPath + $"/testWallet.wallet.json")));
@@ -611,7 +737,7 @@ public void GetUnusedAccountUsingWalletWithoutUnusedAccountsCreatesAccountAndSav
             wallet.AccountsRoot.ElementAt(0).Accounts.Clear();
             walletManager.Wallets.Add(wallet);
 
-            HdAccount result = walletManager.GetUnusedAccount(wallet, "password");
+            IHdAccount result = walletManager.GetUnusedAccount(wallet, "password");
 
             Assert.Equal("account 0", result.Name);
             Assert.True(File.Exists(Path.Combine(dataFolder.WalletPath + $"/testWallet.wallet.json")));
@@ -627,7 +753,7 @@ public void CreateNewAccountGivenNoAccountsExistingInWalletCreatesNewAccount()
             Types.Wallet wallet = this.walletFixture.GenerateBlankWallet("testWallet", "password");
             wallet.AccountsRoot.ElementAt(0).Accounts.Clear();
 
-            HdAccount result = wallet.AddNewAccount("password", DateTimeOffset.UtcNow);
+            IHdAccount result = wallet.AddNewAccount("password", DateTimeOffset.UtcNow);
 
             Assert.Equal(1, wallet.AccountsRoot.ElementAt(0).Accounts.Count);
             var extKey = new ExtKey(Key.Parse(wallet.EncryptedSeed, "password", wallet.Network), wallet.ChainCode);
@@ -651,7 +777,7 @@ public void CreateNewAccountGivenExistingAccountInWalletCreatesNewAccount()
             Types.Wallet wallet = this.walletFixture.GenerateBlankWallet("testWallet", "password");
             wallet.AccountsRoot.ElementAt(0).Accounts.Add(new HdAccount { Name = "unused" });
 
-            HdAccount result = wallet.AddNewAccount("password", DateTimeOffset.UtcNow);
+            IHdAccount result = wallet.AddNewAccount("password", DateTimeOffset.UtcNow);
 
             Assert.Equal(2, wallet.AccountsRoot.ElementAt(0).Accounts.Count);
             var extKey = new ExtKey(Key.Parse(wallet.EncryptedSeed, "password", wallet.Network), wallet.ChainCode);
@@ -1047,7 +1173,7 @@ public void GetAccountsByNameWithExistingWalletReturnsAccountsFromWallet()
 
             walletManager.Wallets.Add(wallet);
 
-            IEnumerable<HdAccount> result = walletManager.GetAccounts("myWallet");
+            IEnumerable<IHdAccount> result = walletManager.GetAccounts("myWallet");
 
             Assert.Equal(2, result.Count());
             Assert.Equal("Account 0", result.ElementAt(0).Name);
@@ -1063,7 +1189,7 @@ public void GetAccountsByNameWithExistingWalletMissingAccountsReturnsEmptyList()
             wallet.AccountsRoot.Clear();
             walletManager.Wallets.Add(wallet);
 
-            IEnumerable<HdAccount> result = walletManager.GetAccounts("myWallet");
+            IEnumerable<IHdAccount> result = walletManager.GetAccounts("myWallet");
 
             Assert.Empty(result);
         }
@@ -1174,7 +1300,7 @@ public void GetSpendableTransactionsReturnsTransactionsGivenBlockHeight()
             wallet.AccountsRoot.Add(new AccountRoot()
             {
                 CoinType = KnownCoinTypes.Stratis,
-                Accounts = new List<HdAccount>
+                Accounts = new List<IHdAccount>
                 {
                     new HdAccount {
                         ExternalAddresses = WalletTestsHelpers.CreateUnspentTransactionsOfBlockHeights(wallet.walletStore as WalletMemoryStore, KnownNetworks.StratisMain, 8,9,10),
@@ -2257,7 +2383,7 @@ public void RemoveBlocksRemovesTransactionsWithHigherBlockHeightAndUpdatesLastSy
                 InternalAddresses = WalletTestsHelpers.CreateSpentTransactionsOfBlockHeights((WalletMemoryStore)wallet.walletStore, this.Network, 1, 2, 3, 4, 5).ToList()
             });
 
-            HdAccount account = wallet.AccountsRoot.ElementAt(0).Accounts.ElementAt(0);
+            IHdAccount account = wallet.AccountsRoot.ElementAt(0).Accounts.ElementAt(0);
 
             // reorg at block 3
             TransactionOutputData data = null;
@@ -2466,7 +2592,7 @@ public void CheckWalletBalanceEstimationWithConfirmedTransactions()
             walletManager.Wallets.Add(WalletTestsHelpers.CreateWallet("wallet1"));
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
 
-            HdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
             WalletMemoryStore store = new WalletMemoryStore();
 
             // add two unconfirmed transactions
@@ -2526,7 +2652,7 @@ public void GetAccountBalancesReturnsCorrectAccountBalances()
             account2.ExternalAddresses.Add(account2Address1);
             account2.InternalAddresses.Add(account2Address2);
 
-            var accounts = new List<HdAccount> { account, account2 };
+            var accounts = new List<IHdAccount> { account, account2 };
 
             Types.Wallet wallet = WalletTestsHelpers.CreateWallet("myWallet");
             wallet.walletStore = store;
@@ -2566,7 +2692,7 @@ public void CheckWalletBalanceEstimationWithUnConfirmedTransactions()
             walletManager.Wallets.Add(wallet);
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
 
-            HdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
 
             // add two confirmed transactions
             for (int i = 1; i < 3; i++)
@@ -2593,7 +2719,7 @@ public void CheckWalletBalanceEstimationWithSpentTransactions()
             walletManager.Wallets.Add(wallet);
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
 
-            HdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
 
             // add two spent transactions
             for (int i = 1; i < 3; i++)
@@ -2620,7 +2746,7 @@ public void CheckWalletBalanceEstimationWithSpentAndConfirmedTransactions()
             walletManager.Wallets.Add(wallet);
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
 
-            HdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
 
             // add two spent transactions
             for (int i = 1; i < 3; i++)
@@ -2653,7 +2779,7 @@ public void CheckWalletBalanceEstimationWithSpentAndUnConfirmedTransactions()
             walletManager.Wallets.Add(wallet);
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
 
-            HdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = walletManager.Wallets.First().AccountsRoot.Single().Accounts.First();
 
             // add two spent transactions
             for (int i = 1; i < 3; i++)
@@ -2941,7 +3067,7 @@ public void RemoveAllTransactionsInWalletReturnsRemovedTransactionsList()
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
             walletManager.LoadKeysLookup();
 
-            HdAccount firstAccount = wallet.AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = wallet.AccountsRoot.Single().Accounts.First();
 
             // Add two unconfirmed transactions.
             uint256 trxId = uint256.Parse("d6043add63ec364fcb591cf209285d8e60f1cc06186d4dcbce496cdbb4303400");
@@ -2988,7 +3114,7 @@ public void RemoveAllTransactionsWhenNoTransactionsArePresentReturnsEmptyList()
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
             walletManager.LoadKeysLookup();
 
-            HdAccount firstAccount = wallet.AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = wallet.AccountsRoot.Single().Accounts.First();
 
             int transactionCount = firstAccount.GetCombinedAddresses().SelectMany(a => wallet.walletStore.GetForAddress(a.Address)).Count();
             Assert.Equal(0, transactionCount);
@@ -3017,7 +3143,7 @@ public void RemoveTransactionsByIdsWhenTransactionsAreUnconfirmedReturnsRemovedT
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
             walletManager.LoadKeysLookup();
 
-            HdAccount firstAccount = wallet.AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = wallet.AccountsRoot.Single().Accounts.First();
 
             // Add two unconfirmed transactions.
             uint256 trxId = uint256.Parse("d6043add63ec364fcb591cf209285d8e60f1cc06186d4dcbce496cdbb4303400");
@@ -3161,7 +3287,7 @@ public void RemoveTransactionsByIdsAlsoRemovesUnconfirmedSpendingDetailsTransact
             WalletTestsHelpers.AddAddressesToWallet(walletManager, 20);
             walletManager.LoadKeysLookup();
 
-            HdAccount firstAccount = wallet.AccountsRoot.Single().Accounts.First();
+            IHdAccount firstAccount = wallet.AccountsRoot.Single().Accounts.First();
 
             // Add two unconfirmed transactions.
             uint256 trxId = uint256.Parse("d6043add63ec364fcb591cf209285d8e60f1cc06186d4dcbce496cdbb4303400");
@@ -3215,7 +3341,7 @@ public void Start_takes_account_of_address_buffer_even_for_existing_wallets()
             walletManager.CreateWallet("test", "mywallet", passphrase: new Mnemonic(Wordlist.English, WordCount.Eighteen).ToString());
 
             // Default of 20 addresses becuause walletaddressbuffer not set
-            HdAccount hdAccount = walletManager.Wallets.Single().AccountsRoot.Single().Accounts.Single();
+            IHdAccount hdAccount = walletManager.Wallets.Single().AccountsRoot.Single().Accounts.Single();
             Assert.Equal(20, hdAccount.ExternalAddresses.Count);
             Assert.Equal(20, hdAccount.InternalAddresses.Count);
 
@@ -3338,7 +3464,7 @@ public void CreateDefaultWalletAndVerifyUnlockAndLocking()
 
             var wallet = walletManager.GetWalletByName("default");
 
-            HdAccount account = walletManager.GetAccounts("default").Single();
+            IHdAccount account = walletManager.GetAccounts("default").Single();
             var reference = new WalletAccountReference("default", account.Name);
 
             var extKey1 = walletManager.GetExtKey(reference);

From 8b3b554c9c0a1c951b29f8edb20c3a437398f94b Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:29:28 +0100
Subject: [PATCH 12/24] Handling strange build problems.

---
 .../Blockcore.Features.RPC/RPCMiddleware.cs      | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/Features/Blockcore.Features.RPC/RPCMiddleware.cs b/src/Features/Blockcore.Features.RPC/RPCMiddleware.cs
index 691432cd2..49157a045 100644
--- a/src/Features/Blockcore.Features.RPC/RPCMiddleware.cs
+++ b/src/Features/Blockcore.Features.RPC/RPCMiddleware.cs
@@ -84,7 +84,7 @@ public async Task InvokeAsync(HttpContext httpContext)
                     throw new NotImplementedException("The request is not supported.");
                 }
 
-                httpContext.Response.ContentType = ContentType;
+                httpContext.Response.ContentType = this.ContentType;
 
                 // Write the response body.
                 using (StreamWriter streamWriter = new StreamWriter(httpContext.Response.Body, Encoding.Default, 1024, true))
@@ -134,44 +134,44 @@ private async Task HandleRpcInvokeExceptionAsync(HttpContext httpContext, Except
             if (ex is ArgumentException || ex is FormatException)
             {
                 JObject response = CreateError(RPCErrorCode.RPC_MISC_ERROR, "Argument error: " + ex.Message);
-                httpContext.Response.ContentType = ContentType;
+                httpContext.Response.ContentType = this.ContentType;
                 await httpContext.Response.WriteAsync(response.ToString(Formatting.Indented));
             }
             else if (ex is BlockNotFoundException)
             {
                 JObject response = CreateError(RPCErrorCode.RPC_INVALID_REQUEST, "Argument error: " + ex.Message);
-                httpContext.Response.ContentType = ContentType;
+                httpContext.Response.ContentType = this.ContentType;
                 await httpContext.Response.WriteAsync(response.ToString(Formatting.Indented));
             }
             else if (ex is ConfigurationException)
             {
                 JObject response = CreateError(RPCErrorCode.RPC_INTERNAL_ERROR, ex.Message);
-                httpContext.Response.ContentType = ContentType;
+                httpContext.Response.ContentType = this.ContentType;
                 await httpContext.Response.WriteAsync(response.ToString(Formatting.Indented));
             }
             else if (ex is RPCServerException)
             {
                 var rpcEx = (RPCServerException)ex;
                 JObject response = CreateError(rpcEx.ErrorCode, ex.Message);
-                httpContext.Response.ContentType = ContentType;
+                httpContext.Response.ContentType = this.ContentType;
                 await httpContext.Response.WriteAsync(response.ToString(Formatting.Indented));
             }
             else if (httpContext.Response?.StatusCode == 404)
             {
                 JObject response = CreateError(RPCErrorCode.RPC_METHOD_NOT_FOUND, "Method not found");
-                httpContext.Response.ContentType = ContentType;
+                httpContext.Response.ContentType = this.ContentType;
                 await httpContext.Response.WriteAsync(response.ToString(Formatting.Indented));
             }
             else if (this.IsDependencyFailure(ex))
             {
                 JObject response = CreateError(RPCErrorCode.RPC_METHOD_NOT_FOUND, ex.Message);
-                httpContext.Response.ContentType = ContentType;
+                httpContext.Response.ContentType = this.ContentType;
                 await httpContext.Response.WriteAsync(response.ToString(Formatting.Indented));
             }
             else if (httpContext.Response?.StatusCode == 500 || ex != null)
             {
                 JObject response = CreateError(RPCErrorCode.RPC_INTERNAL_ERROR, "Internal error");
-                httpContext.Response.ContentType = ContentType;
+                httpContext.Response.ContentType = this.ContentType;
                 this.logger.LogError(new EventId(0), ex, "Internal error while calling RPC Method");
                 await httpContext.Response.WriteAsync(response.ToString(Formatting.Indented));
             }

From cb5740162268705d47e2f6433caa3c5052001495 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:29:50 +0100
Subject: [PATCH 13/24] Handling strange build problems again

---
 src/Tests/Blockcore.IntegrationTests/GlobalSuppressions.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Tests/Blockcore.IntegrationTests/GlobalSuppressions.cs b/src/Tests/Blockcore.IntegrationTests/GlobalSuppressions.cs
index c34eafe92..ea5e5a531 100644
--- a/src/Tests/Blockcore.IntegrationTests/GlobalSuppressions.cs
+++ b/src/Tests/Blockcore.IntegrationTests/GlobalSuppressions.cs
@@ -4,6 +4,8 @@
 // Project-level suppressions either have no target or are given 
 // a specific target and scoped to a namespace, type, member, etc.
 
+using System.Diagnostics.CodeAnalysis;
+
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~M:Blockcore.IntegrationTests.Miners.ProofOfStakeMintCoinsSpecification.a_proof_of_stake_node_with_wallet")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~M:Blockcore.IntegrationTests.Miners.ProofOfStakeMintCoinsSpecification.a_proof_of_work_node_with_wallet")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>", Scope = "member", Target = "~M:Blockcore.IntegrationTests.Miners.ProofOfStakeMintCoinsSpecification.create_tx_to_send_million_coins_from_pow_wallet_to_pos_node_wallet")]

From 65faa2d31a9f995c13703da573c58f538a6d64e1 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Fri, 17 Sep 2021 20:33:31 +0100
Subject: [PATCH 14/24] Refactored to use interface collection instead of
 concreted class.

---
 .../Api/Controllers/WalletRPCController.cs               | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletRPCController.cs b/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletRPCController.cs
index 1c6020365..c7c5e2aba 100644
--- a/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletRPCController.cs
+++ b/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletRPCController.cs
@@ -9,6 +9,7 @@
 using Blockcore.Consensus.ScriptInfo;
 using Blockcore.Consensus.TransactionInfo;
 using Blockcore.Controllers;
+using Blockcore.Controllers.Models;
 using Blockcore.Features.BlockStore;
 using Blockcore.Features.RPC;
 using Blockcore.Features.RPC.Exceptions;
@@ -23,7 +24,9 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
 using NBitcoin;
+using NBitcoin.Policy;
 using Newtonsoft.Json;
+using Script = Blockcore.Consensus.ScriptInfo.Script;
 
 namespace Blockcore.Features.Wallet.Api.Controllers
 {
@@ -150,7 +153,7 @@ public async Task<uint256> SendToAddressAsync(BitcoinAddress address, decimal am
                 throw new RPCServerException(RPCErrorCode.RPC_WALLET_ERROR, exception.Message);
             }
         }
-
+        
         /// <summary>
         /// Broadcasts a raw transaction from hex to local node and network.
         /// </summary>
@@ -340,7 +343,7 @@ public GetTransactionModel GetTransaction(string txid)
 
             WalletAccountReference accountReference = this.GetWalletAccountReference();
             Types.Wallet wallet = this.walletManager.GetWalletByName(accountReference.WalletName);
-            HdAccount account = this.walletManager.GetAccounts(accountReference.WalletName).Single(a => a.Name == accountReference.AccountName);
+            IHdAccount account = this.walletManager.GetAccounts(accountReference.WalletName).Single(a => a.Name == accountReference.AccountName);
 
             // Get the transaction from the wallet by looking into received and send transactions.
             List<HdAddress> addresses = account.GetCombinedAddresses().ToList();
@@ -901,7 +904,7 @@ private WalletAccountReference GetWalletAccountReference()
                 throw new RPCServerException(RPCErrorCode.RPC_INVALID_REQUEST, "No wallet found");
             }
 
-            HdAccount account = this.walletManager.GetAccounts(walletName).First();
+            IHdAccount account = this.walletManager.GetAccounts(walletName).First();
             return new WalletAccountReference(walletName, account.Name);
         }
     }

From f6a6ff825d44ff3b0810fdfb73b9cd99293be280 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Wed, 29 Sep 2021 23:42:19 +0100
Subject: [PATCH 15/24] Added create multisig wallet operation to
 IWalletManager interface.

---
 .../Interfaces/IWalletManager.cs                    | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Features/Blockcore.Features.Wallet/Interfaces/IWalletManager.cs b/src/Features/Blockcore.Features.Wallet/Interfaces/IWalletManager.cs
index 34d625342..7ed510fd0 100644
--- a/src/Features/Blockcore.Features.Wallet/Interfaces/IWalletManager.cs
+++ b/src/Features/Blockcore.Features.Wallet/Interfaces/IWalletManager.cs
@@ -429,5 +429,18 @@ public interface IWalletManager
         /// <param name="broadcast">Broadcast the transaction to the network.</param>
         /// <returns>List of sweep transactions.</returns>
         IEnumerable<string> Sweep(IEnumerable<string> privateKeys, string destAddress, bool broadcast);
+
+        /// <summary>
+        /// Creates mutisig wallet with 1 private key and list of xPub keys
+        /// </summary>
+        /// <param name="walletName">Wallet name</param>
+        /// <param name="threashold">Number of signatures required for transaction to be valid.</param>
+        /// <param name="cosignerXPubs">Extended pubkeys for other cosigners.</param>
+        /// <param name="coinType">Coin type as per https://github.com/satoshilabs/slips/blob/master/slip-0044.md</param>
+        /// <param name="mnemonic">Mnemonic wallet recovery seed.</param>
+        /// <param name="password">A wallet encryption password.</param>
+        /// <param name="passphrase">Passphrase as seed extension word.</param>
+        /// <returns></returns>
+        WalletMultisig CreateMutisigWallet(string walletName, int threashold, List<string> cosignerXPubs, int coinType, string mnemonic, string password, string passphrase);
     }
 }
\ No newline at end of file

From 432606850529363e9566e730f8de3f18822822f4 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Wed, 29 Sep 2021 23:45:03 +0100
Subject: [PATCH 16/24] Added explicit network parameter to GeneratePublicKey
 with default null to be backward compatible.

---
 .../Blockcore.Features.Wallet/Helpers/HdOperations.cs        | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Features/Blockcore.Features.Wallet/Helpers/HdOperations.cs b/src/Features/Blockcore.Features.Wallet/Helpers/HdOperations.cs
index 01cc1ff9c..c3212fec1 100644
--- a/src/Features/Blockcore.Features.Wallet/Helpers/HdOperations.cs
+++ b/src/Features/Blockcore.Features.Wallet/Helpers/HdOperations.cs
@@ -17,17 +17,18 @@ public class HdOperations
         /// <param name="accountExtPubKey">The extended public key used to generate child keys.</param>
         /// <param name="index">The index of the child key to generate.</param>
         /// <param name="isChange">A value indicating whether the public key to generate corresponds to a change address.</param>
+        /// <param name="network">Network</param>
         /// <returns>
         /// An HD public key derived from an extended public key.
         /// </returns>
-        public static PubKey GeneratePublicKey(string accountExtPubKey, int index, bool isChange)
+        public static PubKey GeneratePublicKey(string accountExtPubKey, int index, bool isChange, Network network = null)
         {
             Guard.NotEmpty(accountExtPubKey, nameof(accountExtPubKey));
 
             int change = isChange ? 1 : 0;
             var keyPath = new KeyPath($"{change}/{index}");
             // TODO: Should probably explicitly be passing the network into Parse
-            ExtPubKey extPubKey = ExtPubKey.Parse(accountExtPubKey).Derive(keyPath);
+            ExtPubKey extPubKey = ExtPubKey.Parse(accountExtPubKey, network).Derive(keyPath);
             return extPubKey.PubKey;
         }
 

From 210650d1949a63de8c6c6e556eacb9e4e7355537 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Wed, 29 Sep 2021 23:46:22 +0100
Subject: [PATCH 17/24] Created transaction hex response model for wallet RPCs.

---
 .../Api/Models/TransactionHexModel.cs          | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 src/Features/Blockcore.Features.Wallet/Api/Models/TransactionHexModel.cs

diff --git a/src/Features/Blockcore.Features.Wallet/Api/Models/TransactionHexModel.cs b/src/Features/Blockcore.Features.Wallet/Api/Models/TransactionHexModel.cs
new file mode 100644
index 000000000..3cf24d43f
--- /dev/null
+++ b/src/Features/Blockcore.Features.Wallet/Api/Models/TransactionHexModel.cs
@@ -0,0 +1,18 @@
+using Newtonsoft.Json;
+
+namespace Blockcore.Features.Wallet.Api.Models
+{
+
+    public class TransactionHexModel
+    {
+        /// <summary>The transaction bytes as a hexadecimal string.</summary>
+        [JsonProperty(PropertyName = "transactionHex")]
+        public string TransactionHex { get; set; }
+
+        
+        public override string ToString()
+        {
+            return this.TransactionHex;
+        }
+    }
+}

From 0e93ac625f83460b92dd3d2cb68b59c374d11a10 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Wed, 29 Sep 2021 23:51:37 +0100
Subject: [PATCH 18/24] Changed HD paths back to m/44' from m/45' as this was
 breaking private key deriviation.

---
 .../Types/WalletMultisig.cs                   | 38 ++++++++-----------
 1 file changed, 15 insertions(+), 23 deletions(-)

diff --git a/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs b/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
index 82be6b7c0..a4704805b 100644
--- a/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
+++ b/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
@@ -13,22 +13,9 @@ namespace Blockcore.Features.Wallet.Types
 {
     public class WalletMultisig : Wallet
     {
-        public WalletMultisig(List<AccountRootMultisig> accountsRoot, ICollection<uint256> blockLocator, byte[] chaincode, DateTimeOffset creationTime, string name, Network network)
-        {
-            this.AccountsRoot = (ICollection<IAccountRoot>)accountsRoot;
-            this.BlockLocator = blockLocator;
-            this.ChainCode = chaincode;
-            this.CreationTime = creationTime;
-            this.EncryptedSeed = string.Empty;
-            this.IsMultisig = true;
-            this.IsExtPubKeyWallet = true;
-            this.Name = name;
-            this.Network = network;
-        }
         public WalletMultisig()
         {
             this.IsMultisig = true;
-            this.EncryptedSeed = string.Empty;
             this.AccountsRoot = new List<IAccountRoot>();
         }
 
@@ -36,6 +23,15 @@ public WalletMultisig(Network network):this()
         {
             this.Network = network;            
         }
+
+        public WalletMultisig(string walletName, string encryptedSeed, byte[] chainCode, Network network):this()
+        {
+            this.Name = walletName;
+            this.EncryptedSeed = encryptedSeed;
+            this.ChainCode = chainCode;
+            this.Network = network;
+        }
+
         /// <summary>
         /// The root of the accounts tree.
         /// </summary>
@@ -76,8 +72,8 @@ public HdAccountMultisig AddNewAccount(MultisigScheme multisigScheme, int coinTy
             {
                 newAccountIndex = accounts.Max(a => a.Index) + 1;
             }
-
-            string accountHdPath = $"m/45'/{(int)coinType}'/{newAccountIndex}'";
+            
+            string accountHdPath = $"m/44'/{(int)coinType}'/{newAccountIndex}'";
 
             var newAccount = new HdAccountMultisig(multisigScheme)
             {
@@ -123,7 +119,6 @@ public class AccountRootMultisigConverter : JsonConverter
     {
         public override bool CanConvert(Type objectType)
         {
-            //assume we can convert to anything for now
             return true;
         }
 
@@ -146,7 +141,6 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 
         public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
         {
-            //use the default serialization - it works fine
             serializer.Serialize(writer, value);
         }
     }
@@ -155,7 +149,6 @@ public class HdAccountMultisigConverter : JsonConverter
     {
         public override bool CanConvert(Type objectType)
         {
-            //assume we can convert to anything for now
             return true;
         }
 
@@ -199,12 +192,12 @@ public HdAccountMultisig(MultisigScheme scheme)
         /// An HD public key derived from an extended public key.
         /// </returns>
 
-        public Script GeneratePublicKey(int hdPathIndex, bool isChange = false)
+        public Script GeneratePublicKey(int hdPathIndex, Network network, bool isChange = false)
         {
             List<PubKey> derivedPubKeys = new List<PubKey>();
             foreach (var xpub in this.MultisigScheme.XPubs)
             {
-                derivedPubKeys.Add(HdOperations.GeneratePublicKey(xpub, hdPathIndex, isChange));
+                derivedPubKeys.Add(HdOperations.GeneratePublicKey(xpub, hdPathIndex, isChange, network));
             }
             var sortedkeys = LexographicalSort(derivedPubKeys);
 
@@ -240,7 +233,7 @@ public override IEnumerable<HdAddress> CreateAddresses(Network network, int addr
             for (int i = firstNewAddressIndex; i < firstNewAddressIndex + addressesQuantity; i++)
             {
                 // Generate a new address.                
-                var pubkey = GeneratePublicKey(i, isChange);
+                var pubkey = GeneratePublicKey(i, network, isChange);
                 BitcoinAddress address = pubkey.Hash.GetAddress(network);
                 // Add the new address details to the list of addresses.
                 HdAddress newAddress = new HdAddress
@@ -251,7 +244,6 @@ public override IEnumerable<HdAddress> CreateAddresses(Network network, int addr
                     Pubkey = pubkey,
                     Address = address.ToString(),
                     RedeemScript = pubkey
-                    //Transactions = new List<TransactionData>()
                 };
 
                 addresses.Add(newAddress);
@@ -273,7 +265,7 @@ public override IEnumerable<HdAddress> CreateAddresses(Network network, int addr
         public static string CreateHdPath(int coinType, int accountIndex, int addressIndex, bool isChange = false)
         {
             int change = isChange ? 1 : 0;
-            return $"m/45'/{coinType}'/{accountIndex}'/{change}/{addressIndex}";
+            return $"m/44'/{coinType}'/{accountIndex}'/{change}/{addressIndex}";
         }
 
         private static IEnumerable<PubKey> LexographicalSort(IEnumerable<PubKey> pubKeys)

From a5e4b00547a80b7264e9c3c3d6c79a98897d7507 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Wed, 29 Sep 2021 23:53:53 +0100
Subject: [PATCH 19/24] Cleand up imports /usings.

---
 src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs b/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
index a4704805b..66df0c4c7 100644
--- a/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
+++ b/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
@@ -5,7 +5,6 @@
 using Blockcore.Features.Wallet.Helpers;
 using Blockcore.Features.Wallet.Interfaces;
 using Blockcore.Networks;
-using Blockcore.Utilities.JsonConverters;
 using NBitcoin;
 using Newtonsoft.Json;
 

From 982f81e5fcd343cb3a657fcc763e72d2c1b35e8d Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Wed, 29 Sep 2021 23:56:51 +0100
Subject: [PATCH 20/24] Updated CreateMutisigWallet to use seed and xpubs as
 previous version was reduced to just readonly multisig wallet.

---
 .../WalletManager.cs                          | 44 +++++++++----------
 1 file changed, 21 insertions(+), 23 deletions(-)

diff --git a/src/Features/Blockcore.Features.Wallet/WalletManager.cs b/src/Features/Blockcore.Features.Wallet/WalletManager.cs
index b62e7294b..9d57461c1 100644
--- a/src/Features/Blockcore.Features.Wallet/WalletManager.cs
+++ b/src/Features/Blockcore.Features.Wallet/WalletManager.cs
@@ -295,16 +295,33 @@ public void Stop()
                 disposable?.Dispose();
         }
 
-        public WalletMultisig CreateMutisigWallet(string walletName, int threashold, string[] xPubs, int coinType)
+        public WalletMultisig CreateMutisigWallet(string walletName, int threashold, List<string> cosignerXPubs, int coinType, string mnemonic, string password, string passphrase)
         {
+            Guard.NotEmpty(password, nameof(password));
+            Guard.NotEmpty(walletName, nameof(walletName));
+            Guard.NotEmpty(mnemonic, nameof(mnemonic));
+            Guard.NotNull(passphrase, nameof(passphrase));
+
+            ExtKey extendedKey = HdOperations.GetExtendedKey(mnemonic, passphrase);
+
+            string encryptedSeed = extendedKey.PrivateKey.GetEncryptedBitcoinSecret(password, this.network).ToWif();
+
+            string accountHdPath = HdOperations.GetAccountHdPath((int)coinType, 0);
+            Key privateKey = HdOperations.DecryptSeed(encryptedSeed, password, this.network);
+
+            ExtPubKey accountExtPubKey = HdOperations.GetExtendedPublicKey(privateKey, extendedKey.ChainCode, accountHdPath);
+  
+
+            cosignerXPubs.Add(accountExtPubKey.ToString(this.network));
+
             var multisigScheme = new MultisigScheme()
             {
                 Threashold = threashold,
-                XPubs = xPubs
+                XPubs = cosignerXPubs.ToArray()
             };
 
-            WalletMultisig wallet = new WalletMultisig(this.network);
-            wallet.Name = walletName;
+            WalletMultisig wallet = new WalletMultisig(walletName, encryptedSeed, extendedKey.ChainCode, this.network);
+
             var root = new AccountRootMultisig
             {
                 CoinType = coinType
@@ -1597,29 +1614,10 @@ public void SaveWallet(Types.Wallet wallet)
                 wallet.walletStore.SetData(walletData);
                 if (!wallet.IsMultisig)
                 {
-                    //var knownTypes = new KnownTypesBinder
-                    //{
-                    //    KnownTypes = new List<Type>
-                    //    {
-                    //        typeof(Types.Wallet),
-                    //        typeof(Types.AccountRoot),
-                    //        typeof(Types.HdAccount),
-                    //    }
-                    //};
                     this.fileStorage.SaveToFile(wallet, $"{wallet.Name}.{WalletFileExtension}", new FileStorageOption { SerializeNullValues = false });
                 }
                 else
                 {
-                    //var knownTypes = new KnownTypesBinder
-                    //{
-                    //    KnownTypes = new List<Type>
-                    //    {
-                    //        typeof(Types.WalletMultisig),
-                    //        typeof(Types.AccountRootMultisig),
-                    //        typeof(Types.HdAccountMultisig),
-                    //    }
-                    //};
-
                     this.multisigFileStorage.SaveToFile((WalletMultisig)wallet, $"{wallet.Name}.{WalletMultisigFileExtension}", new FileStorageOption { SerializeNullValues = false });
                 }
                 

From 978c3d96a35b5a7e8e01cda6af645f57fe8c3e80 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Wed, 29 Sep 2021 23:58:38 +0100
Subject: [PATCH 21/24] Modified tests to verify private key + (n)xpub multisig
 wallet.

---
 .../MultisigWalletTest.cs                     | 46 +++++++++++++++----
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/MultisigWalletTest.cs b/src/Tests/Blockcore.Features.Wallet.Tests/MultisigWalletTest.cs
index ae915601e..7ef3f6687 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/MultisigWalletTest.cs
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/MultisigWalletTest.cs
@@ -2,21 +2,23 @@
 using System.Collections.Generic;
 using System.Text;
 using Blockcore.Consensus.ScriptInfo;
+using Blockcore.Features.Wallet.Helpers;
 using Blockcore.Features.Wallet.Types;
 using Blockcore.Networks;
 using Blockcore.Networks.XRC;
+using NBitcoin;
 using Xunit;
 
 namespace Blockcore.Features.Wallet.Tests
 {
     public class MultisigWalletTest
     {
-        private readonly Network network;
+        private readonly Network Network;
         private readonly MultisigScheme multisigScheme;
         private const int COINTYPE = 10291;
         public MultisigWalletTest()
         {
-            this.network = new XRCMain();
+            this.Network = new XRCMain();
             this.multisigScheme = new MultisigScheme()
             {
                 Threashold = 2,
@@ -29,11 +31,35 @@ public MultisigWalletTest()
             };
         }
 
+        [Fact]
+        public void pubKeysDerivedFromExtendedPrivateAndPublicKeysMatch() {
+          
+            string password = "bdemq1XLhLYbiGHD";
+            string passphrase = password;
+
+            string mnemonic = "chalk call anger chase endless level slow sleep coast left sand enter save bind curious puzzle stadium volume mixture shuffle hurry gas borrow believe";
+
+            ExtKey extendedKey = HdOperations.GetExtendedKey(mnemonic, passphrase);
+
+            string encryptedSeed = extendedKey.PrivateKey.GetEncryptedBitcoinSecret(password, this.Network).ToWif();
+            Key privateKey = HdOperations.DecryptSeed(encryptedSeed, password, this.Network);
+
+            string accountHdPath = HdOperations.GetAccountHdPath(COINTYPE, 0);
+            string path = HdOperations.CreateHdPath(COINTYPE, 0, false, 0);
+
+            ExtPubKey accountExtPubKey = HdOperations.GetExtendedPublicKey(privateKey, extendedKey.ChainCode, accountHdPath);
+            var subjectPubKey = HdOperations.GeneratePublicKey(accountExtPubKey.ToString(this.Network), 0, false, this.Network);
+
+            var subjectPrivKey = HdOperations.GetExtendedPrivateKey(privateKey, extendedKey.ChainCode, path, this.Network);
+
+            Assert.Equal(subjectPubKey.ScriptPubKey, subjectPrivKey.PrivateKey.PubKey.ScriptPubKey);
+        }        
+
         [Fact]
         public void Generate1stMultisigAddress()
         {
 
-            WalletMultisig wallet = new WalletMultisig(this.network);
+            WalletMultisig wallet = new WalletMultisig(this.Network);
             var root = new AccountRootMultisig
             {
                 CoinType = COINTYPE
@@ -41,8 +67,8 @@ public void Generate1stMultisigAddress()
             wallet.AccountsRoot.Add(root);
             var account = wallet.AddNewAccount(this.multisigScheme, COINTYPE, DateTimeOffset.UtcNow);
 
-            Script redeemScript = account.GeneratePublicKey(0);
-            Assert.Equal("rbAxG3vTMCuVMWppaobvTajBtUHSiFtkr5", redeemScript.Hash.GetAddress(this.network).ToString());
+            Script redeemScript = account.GeneratePublicKey(0, this.Network);
+            Assert.Equal("rbAxG3vTMCuVMWppaobvTajBtUHSiFtkr5", redeemScript.Hash.GetAddress(this.Network).ToString());
         }
 
         [Fact]
@@ -51,7 +77,7 @@ public void Generate4SequnetialMultisigRecievingAndChangeAddress()
             string[] receiving = { "rbAxG3vTMCuVMWppaobvTajBtUHSiFtkr5", "roLKXofxDFrkZqW7kU9aD7j7E6pTajEe16", "rjmcR79w6MatNK3KeHR3FvaEEHngdAKa9h", "reD6MyXPFUaJpyBtJVDgdYf7iN4qHbhzBz" };
             string[] change = { "rXh3PVYpn462fDTAmLiUyKZ1aTWdzr4W9J", "rjNVcwuXKW1d8j8CQbxK4Kim5Hkg7Z4ZhL", "rginUKQEG9XjQVfhJ5ho7P4v9ENrtvF8Uk", "rgeVtHemGFGQzRU2Dhj3gYTgsWcjg4wgG5" };
 
-            WalletMultisig wallet = new WalletMultisig(this.network);
+            WalletMultisig wallet = new WalletMultisig(this.Network);
             var root = new AccountRootMultisig
             {
                 CoinType = COINTYPE
@@ -61,14 +87,14 @@ public void Generate4SequnetialMultisigRecievingAndChangeAddress()
 
             for (int i = 0; i < receiving.Length; i++)
             {
-                Script redeemScript = account.GeneratePublicKey(i);
-                Assert.Equal(receiving[i], redeemScript.Hash.GetAddress(this.network).ToString());
+                Script redeemScript = account.GeneratePublicKey(i, this.Network);
+                Assert.Equal(receiving[i], redeemScript.Hash.GetAddress(this.Network).ToString());
             }
 
             for (int i = 0; i < change.Length; i++)
             {
-                Script redeemScript = account.GeneratePublicKey(i, true);
-                Assert.Equal(change[i], redeemScript.Hash.GetAddress(this.network).ToString());
+                Script redeemScript = account.GeneratePublicKey(i, this.Network, true);
+                Assert.Equal(change[i], redeemScript.Hash.GetAddress(this.Network).ToString());
             }
         }
     }

From 595051482fa8632b4e547a7219e31496b716f0bf Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Wed, 29 Sep 2021 23:59:23 +0100
Subject: [PATCH 22/24] Modified tests to verify private key + (n)xpub multisig
 wallet.

---
 .../WalletManagerTest.cs                      | 47 ++++++++++---------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/Tests/Blockcore.Features.Wallet.Tests/WalletManagerTest.cs b/src/Tests/Blockcore.Features.Wallet.Tests/WalletManagerTest.cs
index 20a7f61b6..730ae3969 100644
--- a/src/Tests/Blockcore.Features.Wallet.Tests/WalletManagerTest.cs
+++ b/src/Tests/Blockcore.Features.Wallet.Tests/WalletManagerTest.cs
@@ -49,7 +49,7 @@ public WalletManagerTest(WalletFixture walletFixture)
         /// This is more of an integration test to verify fields are filled correctly. This is what I could confirm.
         /// </summary>
         [Fact]
-        public void CreateMultisigXRCWallet()
+        public void CreateMultisigXRCWalletWithSeed()
         {
             DataFolder dataFolder = CreateDataFolder(this);
             this.Network = new XRCMain();
@@ -66,33 +66,37 @@ public void CreateMultisigXRCWallet()
             var walletManager = new WalletManager(this.LoggerFactory.Object, this.Network, chain, new WalletSettings(NodeSettings.Default(this.Network)),
                 dataFolder, new Mock<IWalletFeePolicy>().Object, new Mock<IAsyncProvider>().Object, new NodeLifetime(), DateTimeProvider.Default, new ScriptAddressReader());
 
-            var xPubs = new string[]
+            var xPubs = new List<string>()
             {
-                "xpub661MyMwAqRbcFK4g9bHwLNYLmy4JxSFkKNRURL3hJqVYLoZ318eHmEKjMbFxbgDiaMycDk4oixtRkHKgbopRzukzimmyzAb2aEVfAEeJPxt",
-                "xpub661MyMwAqRbcFVViGz3WGiaYgzsKWKXYduJZ8oR4tnnaRLp2QXMUf5P9Yq6CpJ8zuddutUFyrTkMECqqa1UyjnegVpoiYbcqpJfSCP9GcmG",
-                "xpub661MyMwAqRbcFYCYnw23jLqPAHMvCfmLeKkmDSLGy6nGpVtJvN9EDoR2qdz8fmvkV8sSa1ZT7j8oyfBgjHKX2nGnESLqSndrM2gJ6TGcXrU",
+                "xpub6BjqcxqZxmEMszvyvzhwDZbEcLpLsQCyWrCQjmnLJ3BvXHwwiPNH1W3jmF882W9jsJM5vGspDTzetnXwSy4P4qDgvYR46Adn11PUBvQAW1T", 
+                "xpub6Cnh2EhE9yAggVwQA7mAy2Reh7hP9VsqVMa7FTBckKUYKwHvi1HPJcqwkuunA5V3LRhCvx8EeKdKoxSRFD2GJQeAd7wawJC1jqJvD2HeP8W"
             };
 
             var recieveRedeemScripts = new string[]
             {
-                "522102134708a8b6df4908a73041d97feb75d0b2706710e8dacad9107d26e13c1fcc5521027a4fdc628e20e430e525b098b4fa3ef888765d03651b4d78ff795438ac458dcb210305615df6ea6f4370f2ca4b09f0139523cfca72f0df7588d85eced64b51e25e0053ae",
-                "522102e8bf4c7f1a483ff6e42fda3a4b99acf35f53d1dc2e19b41428d693d86cc7457b21037a5ba1a77965d5c3212a3c596ff05843c098b7f1fd0a302a505fb26d0b7cbe1a2103f3a2ed18c90dffad6535950de5d22677d9c7f88d6b61e221544fd8d26184693153ae",
-                "52210225a49e0cc70ee1a2aa63ae98f12fe644069d0b591c77967394a53709dd0730782102ab2bb7280689df3167c2fe80cd0abd3c3cf1ba769b235ed5155b18a0b2fa9e192103c01f3c9b8bdff0329f9e05a61cf4b5d50ceddafc39300d74411c8f2a46b91cbb53ae",
-                "522102db7982444aa7218263e8e075b50f7fa59b14f1288b358ad677ff7bf1b2aaa8d121039e67696312bb838d755efd221734349fa5db59a4385d8241460a1ba3c2e62bfe2103c71608f27b41be9d6822fd50f31bfff0ce691a16ba760ed821801a07512d965653ae",
-                "5221026135f28080e9e91f693e7458a52a6727b8130d8f689d3d58fb25eee70f099f2021035c604fe5ec14740bd2fbca5913054730c5fc2245f45392f3fcbfdd30f939b8b32103e33eb2a622d8dbb420b88b836841eb7d6b39d5637f718610df566fa3c50d297d53ae",
+                "522102af76842fc756db497b984f14ccfa6f0d16c86cf5f3f8a4d2711ffb1d4a1eb4fe210300037e7d78e4f52d4431a586335c16eae6ce0f1afebe841231d913b6fe45a2af21034ec89eb5faa3638ec6b93c24ab75e9f02d11289ee519809cb187bb71cee4e02d53ae",
+                "522102613dc4f647b8feb0907fa6ba9f8dcb0a9319c93d80653a7858f156a6dc3501b221031384c54a42164e0c70a40f9b97b1a4922ca778fd6d43fac669c9b84d7edc4c152103c7d4e479dcb45a26f7f6911e2f66fc3d11ef6170d4f763fab6c4520921f700e853ae",
+                "5221024a7088f372ca162025f3ddbad6c99ed4d828d9c819c368caa3bc42450f44fb092102784c59f90d06fef61d4fb04a9275ca29219821938240f104bddd6dca2ec48de5210280d767323327d01aa05458ea166c0d74431c778505a2ea7d870b07167c8a4dfc53ae",
+                "52210278f2fcb9987d3f8d6a1ab5fe5696379b7cff8c0f1e5184bc4861a7f89e22241b2102f7d134704d07d2cc6f9d50afbba71e44ea71999f705656908b0e4e16615cd6f221036e26d114735ac210e698fe525ddfd47df3fd4ba005c6174395f4e5ea5e98249353ae",
+                "5221020c82ebeaf0420684d377899968715dc10308b011748d8c160c242d485cd90f36210375095b989a1d0100962d38b8f6ebbefff726350e1a0dc7602fb7afb119df45fd2103ca9111db12a21bf89106339a99a69b68047e421f3a42b943f9b19bf52520fe4b53ae",
             };
 
             var changeRedeemScripts = new string[]
             {
-                "52210230b1265c672328e722e06bf5395edb3dc77f27064de1dde9ee55771d59091b0521036feaf4e275bf6be6c7d4ec11969ea7f1c2e51a1b8e364b5450ab6055caf4ed462103b6bdb98fce45ae9cc0ac84359edc870ee9c37ab40961bfe3397e98ce6cf1e75c53ae",
-                "522102923652c9b6220b61a06b1907c700679d07a6895c35cfd612e7cb32f7b485fe622102f32b590744b70c0054b36736bc4fb7711b6126d33784537a50075aa5d7e0aaa5210314bc014000fd5f4469deaaeedc32da2e8aafc4d0519c16c581f184be78211a7c53ae",
-                "5221028de4dafd843231bc1b314192af8dcac9e974fe7c57171fbc3dcdeafa23be68312102c3d99d45c9ce81afc3f7cf1affe0f46e4675fd4feb822347f063b40391c0e74b2103861b41d6d67c19c0676f0906f0e6f74eb36a16fb72b209279fdea2962d7bc36753ae",
-                "52210215adb25ce0663b62afa80d3f9e4c212916181538b3cbb27b8d506577a77730d521032f1598232775df6008a3a36fcd20b630345fd087d648c7b37f85d470386227872103e940b74d39ee703bf87035ae21d76b4e560e3525a1fc1120d49507abe0f131ed53ae",
-                "52210238e487536141e85e96d5fce77227951c53704b6288e8a85bc2de8d61bae3f830210296fcf49b9ee68c52e977ece9e8f3a245675d5fe8bdd766ddd73f55b3f9d534ae2103bb37235320477cefa081bb01c8952538607b6ef146b60750610520e66c35e30453ae",
+                "5221023bc1b977890204ab69eced05b5c6259db7555ab95116b838f950e350806c15d92102910c7e86a0cc485dc992caef88a78f919b8c74b281c5f5a4431bbc541361c51f21029fe588173670c6c28d49a7cc6c1a0222a8dcc0609a0cdd98b0ab5492cc5ba78f53ae",
+                "5221024026c42573ae2cfda5f22aa76bb774696707d3f5d58368578b5ee06e6c97bba9210265f1f62947b908156e9b5b8ee64dd9ce92ee1e53467dac154d819ca82f2407a921027d59cfb9b1f7d61eeeb1442003d110a0ec6de021099a494b235b20ad746301c753ae",
+                "5221024c573939f84a4f25c38931be3b549ddcb8aeab5a8c3495c8b3ffc26974c752a8210308c910a1363afdd5b26f2584512cd1c7eb368caecb403ec64e97726e4aafac0b2103471d2ca002d7c3d677f5df243f37cecb0590c75cec09a6e6f60c5981a894f75a53ae",
+                "522102b5473119cc06852b76ae0b7df36b1c1d862254b6ddde2b9d3b200925aa895c1b2102e113754108029c015c8b9cb5c24a78904ca050c54f2a08d8f80c85d593b7cb662103db1afa7afac4020291b726fc7435e1bdd1e0084050e896c948a17672872a883153ae",
+                "522102148f8f6cd405defd54c7d397a98bb6a064c76daec9ef6e0eeac8b2137782b30b21034d797d8bfdb35d5634d6a7251a829835d155e822b3e2bed9932afd3f2e981012210361277992e5ba401846d53a02f9d4ca8cb94f01bd7f4ddf4a0ce0378af09c6e3b53ae",
             };
 
+            string password = "bdemq1XLhLYbiGHD";
+            string passphrase = "bdemq1XLhLYbiGHD";
+
+            string seed = "chalk call anger chase endless level slow sleep coast left sand enter save bind curious puzzle stadium volume mixture shuffle hurry gas borrow believe";
+
             // create the wallet
-            WalletMultisig expectedWallet = walletManager.CreateMutisigWallet("mywallet", 2, xPubs, 10291);
+            WalletMultisig expectedWallet = walletManager.CreateMutisigWallet("mywallet", 2, xPubs, 10291, seed, password, passphrase);
 
             // assert it has saved it to disk and has been created correctly.
             var actualWallet = walletManager.MultisigFileStorage.LoadByFileName("mywallet.multisigwallet.json");
@@ -103,7 +107,7 @@ public void CreateMultisigXRCWallet()
             Assert.Equal(expectedWallet.Name, actualWallet.Name);
             Assert.Equal(expectedWallet.Network, actualWallet.Network);
             Assert.True(actualWallet.IsMultisig);
-            Assert.Equal(actualWallet.EncryptedSeed, string.Empty);
+            Assert.Equal(expectedWallet.EncryptedSeed, actualWallet.EncryptedSeed);
             Assert.Equal(expectedWallet.ChainCode, actualWallet.ChainCode);
 
             Assert.Equal(1, expectedWallet.AccountsRoot.Count);
@@ -116,7 +120,7 @@ public void CreateMultisigXRCWallet()
                 Assert.Equal(block.GetHash(), expectedWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHash);
 
                 Assert.Equal(expectedWallet.AccountsRoot.ElementAt(i).CoinType, actualWallet.AccountsRoot.ElementAt(i).CoinType);
-                
+
                 // blockcore wallet does not serialize these, because this has explicit json ignore messages.
                 Assert.Null(actualWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHash);
                 Assert.Null(actualWallet.AccountsRoot.ElementAt(i).LastBlockSyncedHeight);
@@ -129,7 +133,7 @@ public void CreateMultisigXRCWallet()
                     var actualAccount = accountRoot.Accounts.ElementAt(j);
                     Assert.Equal($"account {j}", actualAccount.Name);
                     Assert.Equal(j, actualAccount.Index);
-                    Assert.Equal($"m/45'/10291'/{j}'", actualAccount.HdPath);
+                    Assert.Equal($"m/44'/10291'/{j}'", actualAccount.HdPath);
 
 
                     Assert.Equal("N/A", actualAccount.ExtendedPubKey);
@@ -145,7 +149,7 @@ public void CreateMultisigXRCWallet()
                         Assert.Equal(expectedAddress.ScriptPubKey, actualAddress.ScriptPubKey);
                         Assert.Equal(expectedAddress.ToString(), actualAddress.Address);
                         Assert.Equal(expectedAddressPubKey, actualAddress.Pubkey);
-                        Assert.Equal($"m/45'/10291'/{j}'/1/{k}", actualAddress.HdPath);
+                        Assert.Equal($"m/44'/10291'/{j}'/1/{k}", actualAddress.HdPath);
                         //Assert.Equal(0, actualAddress.Transactions.Count);
                     }
 
@@ -159,7 +163,7 @@ public void CreateMultisigXRCWallet()
                         Assert.Equal(expectedAddress.ScriptPubKey, actualAddress.ScriptPubKey);
                         Assert.Equal(expectedAddress.ToString(), actualAddress.Address);
                         Assert.Equal(expectedAddressPubKey, actualAddress.Pubkey);
-                        Assert.Equal($"m/45'/10291'/{j}'/0/{l}", actualAddress.HdPath);
+                        Assert.Equal($"m/44'/10291'/{j}'/0/{l}", actualAddress.HdPath);
                         //Assert.Equal(0, actualAddress.Transactions.Count);
                     }
                 }
@@ -169,7 +173,6 @@ public void CreateMultisigXRCWallet()
             //blockore wallets have explicit jsonignore directives at time of writing this
             Assert.Null(actualWallet.BlockLocator);
         }
-
         /// <summary>
         /// This is more of an integration test to verify fields are filled correctly. This is what I could confirm.
         /// </summary>

From a3e7c1e41632a3541d19d2db742617f5eaed57dd Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Thu, 30 Sep 2021 00:12:28 +0100
Subject: [PATCH 23/24] Added RPCs to create multisig wallet, create multisig
 transctions, combine signatures.

---
 .../Api/Controllers/WalletRPCController.cs    | 239 +++++++++++++++++-
 1 file changed, 236 insertions(+), 3 deletions(-)

diff --git a/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletRPCController.cs b/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletRPCController.cs
index c7c5e2aba..3b6e2c3b4 100644
--- a/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletRPCController.cs
+++ b/src/Features/Blockcore.Features.Wallet/Api/Controllers/WalletRPCController.cs
@@ -9,13 +9,13 @@
 using Blockcore.Consensus.ScriptInfo;
 using Blockcore.Consensus.TransactionInfo;
 using Blockcore.Controllers;
-using Blockcore.Controllers.Models;
 using Blockcore.Features.BlockStore;
 using Blockcore.Features.RPC;
 using Blockcore.Features.RPC.Exceptions;
 using Blockcore.Features.Wallet.Api.Models;
 using Blockcore.Features.Wallet.Database;
 using Blockcore.Features.Wallet.Exceptions;
+using Blockcore.Features.Wallet.Helpers;
 using Blockcore.Features.Wallet.Interfaces;
 using Blockcore.Features.Wallet.Types;
 using Blockcore.Interfaces;
@@ -24,8 +24,8 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
 using NBitcoin;
-using NBitcoin.Policy;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using Script = Blockcore.Consensus.ScriptInfo.Script;
 
 namespace Blockcore.Features.Wallet.Api.Controllers
@@ -153,7 +153,240 @@ public async Task<uint256> SendToAddressAsync(BitcoinAddress address, decimal am
                 throw new RPCServerException(RPCErrorCode.RPC_WALLET_ERROR, exception.Message);
             }
         }
-        
+
+        /// <summary>
+        /// Create a transaction spending the given inputs and creating new outputs. Outputs can be addresses or data. Returns hex - encoded raw transaction. Note that the transaction's inputs are not signed, and it is not stored in the wallet or transmitted to the network.
+        /// </summary>
+        /// <param name="inputs">A json array of json objects.</param>
+        /// <param name="outputs">A json object with outputs.</param>
+        /// <returns>(string) Hex string of the transaction</returns>
+        [ActionName("createrawtransaction")]
+        [ActionDescription("Create a transaction spending the given inputs and creating new outputs. Outputs can be addresses or data. Returns hex - encoded raw transaction. Note that the transaction's inputs are not signed, and it is not stored in the wallet or transmitted to the network.")]
+        public IActionResult CreateRawTransaction(string inputs, string outputs)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(inputs))
+                {
+                    throw new ArgumentNullException("inputs");
+                }
+                if (string.IsNullOrEmpty(outputs))
+                {
+                    throw new ArgumentNullException("outputs");
+                }
+                Transaction transaction = new Transaction();
+
+                dynamic txIns = JsonConvert.DeserializeObject(inputs);
+                foreach (var input in txIns)
+                {
+                    var txIn = new TxIn(new OutPoint(uint256.Parse((string)input.txid), (uint)input.vout));
+                    if (input.sequence != null)
+                    {
+                        txIn.Sequence = (uint)input.sequence;
+                    }
+                    transaction.AddInput(txIn);
+                }
+
+                Dictionary<string, decimal> parsedOutputs = JsonConvert.DeserializeObject<Dictionary<string, decimal>>(outputs);
+                foreach (KeyValuePair<string, decimal> entry in parsedOutputs)
+                {
+                    var isValid = false;
+                    try
+                    {
+                        // P2PKH
+                        if (BitcoinPubKeyAddress.IsValid(entry.Key, this.Network))
+                        {
+                            isValid = true;
+                        }
+                        else if (BitcoinScriptAddress.IsValid(entry.Key, this.Network))
+                        {
+                            isValid = true;
+                        }
+                    }
+                    catch (Exception)
+                    {
+                        isValid = false;
+                    }
+
+                    if (!isValid) throw new Exception(string.Format("Output address {0} is invalid.", entry.Key));
+
+                    var destination = BitcoinAddress.Create(entry.Key, this.Network).ScriptPubKey;
+                    transaction.AddOutput(new TxOut(new Money(entry.Value, MoneyUnit.BTC), destination));
+                }
+
+                var response = new TransactionHexModel()
+                {
+                    TransactionHex = transaction.ToHex()
+                };
+
+                return this.Json(response);
+                
+            }
+            catch (Exception e)
+            {
+                this.logger.LogError("Exception occurred: {0}", e.ToString());
+                throw new RPCServerException(RPCErrorCode.RPC_WALLET_ERROR, e.Message);
+            }
+        }
+
+        /// <summary>
+        /// Creates mutisig wallet with 1 private key and list of xPub keys
+        /// </summary>
+        /// <param name="walletName">Wallet name</param>
+        /// <param name="threashold">Number of signatures required for transaction to be valid.</param>
+        /// <param name="cosignerXPubs">Extended pubkeys for other cosigners.</param>
+        /// <param name="coinType">Coin type as per https://github.com/satoshilabs/slips/blob/master/slip-0044.md</param>
+        /// <param name="mnemonic">Mnemonic wallet recovery seed.</param>
+        /// <param name="password">A wallet encryption password.</param>
+        /// <param name="passphrase">Passphrase as seed extension word.</param>
+        /// <returns></returns>
+        [ActionName("createmutisigwallet")]
+        [ActionDescription("Creates a multisig wallet.")]
+        public IActionResult CreateMutisigWallet(string walletName, int threashold, string cosignerXPubs, string mnemonicSeed, string password, string passphrase)
+        {
+            List<string> cosigners = new List<string>();
+
+            foreach (var item in JsonConvert.DeserializeObject(cosignerXPubs) as JArray)
+            {
+                cosigners.Add(item.ToString());
+            }
+            var wallet = this.walletManager.CreateMutisigWallet(walletName, threashold, cosigners, this.Network.Consensus.CoinType, mnemonicSeed, password, passphrase);
+            return this.Json(wallet);
+        }
+
+        [ActionName("combinemultisigsignatures")]
+        [ActionDescription("Combines multiple signed (same) transctions into 1 properly signed transaction")]
+        public IActionResult CombineMultisigSignatures(string transactions)
+        {
+            try
+            {
+                List<Transaction> transactionsParsed = new List<Transaction>();
+                List<ScriptCoin> coins = new List<ScriptCoin>();
+
+                foreach (var item in JsonConvert.DeserializeObject(transactions) as JArray)
+                {
+                    transactionsParsed.Add(this.FullNode.Network.CreateTransaction(item.ToString()));
+                }
+
+                WalletAccountReference accountReference = this.GetWalletAccountReference();
+                var wallet = this.walletManager.GetWallet(accountReference.WalletName);
+                if (wallet.IsMultisig)
+                {
+                    // Add keys for signing inputs. This takes time so only add keys for distinct addresses.
+                    foreach (UnspentOutputReference unspentOutput in this.walletManager.GetSpendableTransactionsInWallet(accountReference.WalletName, 1))
+                    {
+                        Script prevscript = unspentOutput.Transaction.ScriptPubKey;
+
+                        if (prevscript.IsScriptType(ScriptType.P2SH) || prevscript.IsScriptType(ScriptType.P2WSH))
+                        {
+                            if (unspentOutput.Address.RedeemScript == null)
+                                throw new WalletException("Missing redeem script");
+
+                            // Provide the redeem script to the builder
+                            var scriptCoin = ScriptCoin.Create(this.Network, unspentOutput.ToOutPoint(), new TxOut(unspentOutput.Transaction.Amount, prevscript), unspentOutput.Address.RedeemScript);
+                            coins.Add(scriptCoin);
+                        }
+                    }
+                }
+
+                Transaction fullySigned = new TransactionBuilder(this.FullNode.Network)
+                    .AddCoins(coins)
+                    .CombineSignatures(transactionsParsed.ToArray());
+
+                var isOk = new TransactionBuilder(this.FullNode.Network)
+                    .AddCoins(coins)
+                    .Verify(fullySigned);
+
+                var response = new TransactionHexModel()
+                {
+                    TransactionHex = fullySigned.ToHex()
+                };
+                return this.Json(response);
+            }
+            catch (Exception e)
+            {
+                this.logger.LogError("Exception occurred: {0}", e.ToString());
+                throw new RPCServerException(RPCErrorCode.RPC_WALLET_ERROR, e.Message);
+            }
+        }
+
+
+        /// <summary>
+        /// Add inputs to a transaction until it has enough in value to meet its out value. This will not accept inputs specified in raw tranaction.It will add at most one change output to the outputs. No existing outputs will be modified unless "subtractFeeFromOutputs" is specified. Note that inputs which were signed may need to be resigned after completion since in/ outputs have been added. The inputs added will not be signed, use signrawtransaction for that. Note that all existing inputs must have their previous output transaction be in the wallet."
+        /// </summary>
+        /// <param name="hdAccountName">HD Account Name - Example: "WalletName/WalletAccount"</param>
+        /// <param name="hex">The hex string of the raw transaction.</param>
+        /// <param name="password">Transaction password.</param>
+        /// <returns>hex of funded transaction</returns>
+        [ActionName("fundandsignmultisigtransaction")]
+        [ActionDescription("Add inputs to a transaction until it has enough in value to meet its out value.")]
+        public IActionResult CreateMultisigTransaction(string account, string hex, string password)
+        {
+            try
+            {
+                List<ScriptCoin> coins = new List<ScriptCoin>();
+                List<ISecret> secrets = new List<ISecret>();
+                
+                var decodedTx = this.FullNode.Network.CreateTransaction(hex);
+
+                if (!string.IsNullOrEmpty(account))
+                    throw new RPCServerException(RPCErrorCode.RPC_METHOD_DEPRECATED, "Use of 'account' parameter has been deprecated");
+
+                WalletAccountReference accountReference = this.GetWalletAccountReference();
+                var wallet = this.walletManager.GetWallet(accountReference.WalletName);
+                if (wallet.IsMultisig)
+                {
+
+                    var msAccount = (HdAccountMultisig)wallet.GetAccounts().First();
+                    // get extended private key
+                    Key privateKey = HdOperations.DecryptSeed(wallet.EncryptedSeed, password, this.Network);
+
+                    // Add keys for signing inputs. This takes time so only add keys for distinct addresses.
+                    foreach (UnspentOutputReference unspentOutput in this.walletManager.GetSpendableTransactionsInWallet(accountReference.WalletName, 1))
+                    {
+                        Script prevscript = unspentOutput.Transaction.ScriptPubKey;
+
+                        if (prevscript.IsScriptType(ScriptType.P2SH) || prevscript.IsScriptType(ScriptType.P2WSH))
+                        {
+                            if (unspentOutput.Address.RedeemScript == null)
+                                throw new WalletException("Missing redeem script");
+
+                            // Provide the redeem script to the builder
+                            var scriptCoin = ScriptCoin.Create(this.Network, unspentOutput.ToOutPoint(), new TxOut(unspentOutput.Transaction.Amount, prevscript), unspentOutput.Address.RedeemScript);
+                            coins.Add(scriptCoin);
+                        }
+
+                        secrets.Add(HdOperations.GetExtendedPrivateKey(privateKey, wallet.ChainCode, unspentOutput.Address.HdPath, this.Network));
+                        //this is much slower as wallet seed is decrypted multiple times for each unspent output.
+                        //secrets.Add(wallet.GetExtendedPrivateKeyForAddress(password, unspentOutput.Address));
+                    }
+                }
+
+
+                //.ContinueToBuild(decodedTx)?
+                var built = new TransactionBuilder(this.FullNode.Network)
+                .SetChange(this.walletManager.GetUnusedChangeAddress(accountReference).ScriptPubKey)
+                .AddCoins(coins)
+                .AddKeys(secrets.ToArray())
+                .SendFees(new Money(10000))
+                .Send(decodedTx.Outputs.First().ScriptPubKey, decodedTx.Outputs.First().Value)
+                .BuildTransaction(true);
+
+                var response = new TransactionHexModel()
+                {
+                    TransactionHex = built.ToHex()
+                };
+                return this.Json(response);
+            }
+            catch (Exception e)
+            {
+                this.logger.LogError("Exception occurred: {0}", e.ToString());
+                throw new RPCServerException(RPCErrorCode.RPC_WALLET_ERROR, e.Message);
+            }
+        }
+
+
+
         /// <summary>
         /// Broadcasts a raw transaction from hex to local node and network.
         /// </summary>

From f1b30664db2f18b197a006f19bf2f2217cac9cd6 Mon Sep 17 00:00:00 2001
From: rodendron <rodendron@xrhodium.org>
Date: Sat, 29 Jan 2022 12:21:49 +0000
Subject: [PATCH 24/24] Bug fix for null LastBlockSynchedHash after creating
 new wallet

---
 src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs b/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
index 66df0c4c7..b96904bd8 100644
--- a/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
+++ b/src/Features/Blockcore.Features.Wallet/Types/WalletMultisig.cs
@@ -65,6 +65,8 @@ public HdAccountMultisig AddNewAccount(MultisigScheme multisigScheme, int coinTy
         {
             // Get the current collection of accounts.
             var accounts = this.AccountsRoot.FirstOrDefault().Accounts;
+            this.AccountsRoot.FirstOrDefault().LastBlockSyncedHash = network.GenesisHash;
+            this.AccountsRoot.FirstOrDefault().LastBlockSyncedHeight = 0;
 
             int newAccountIndex = 0;
             if (accounts.Any())