test: unit tests for all core modules

2026-06-11 10:48:21 +02:00
parent 0e32b9bc9b
commit 34c588c6f4
10 changed files with 974 additions and 0 deletions
@@ -0,0 +1,83 @@
+using NBitcoin;
+using NBitcoin.DataEncoders;
+using PalladiumWallet.Core.Chain;
+
+namespace PalladiumWallet.Tests.Chain;
+
+public class ChainProfileTests
+{
+    [Fact]
+    public void Mainnet_ha_le_costanti_del_blueprint()
+    {
+        var p = ChainProfiles.Mainnet;
+
+        Assert.Equal("PLM", p.CoinUnit);
+        Assert.Equal(0x80, p.WifPrefix);
+        Assert.Equal(55, p.AddrP2pkh);
+        Assert.Equal(5, p.AddrP2sh);
+        Assert.Equal("plm", p.SegwitHrp);
+        Assert.Equal("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f", p.GenesisHash);
+        Assert.Equal(50001, p.DefaultTcpPort);
+        Assert.Equal(50002, p.DefaultSslPort);
+        Assert.Equal(746, p.Bip44CoinType);
+        Assert.Equal("palladium", p.UriScheme);
+        Assert.True(p.SkipPowValidation); // obbligatorio: la catena usa LWMA (§3)
+        Assert.Equal(120, p.BlockTimeSeconds);
+    }
+
+    [Fact]
+    public void Testnet_e_regtest_hanno_i_valori_del_blueprint()
+    {
+        var t = ChainProfiles.Testnet;
+        Assert.Equal(0xff, t.WifPrefix);
+        Assert.Equal(127, t.AddrP2pkh);
+        Assert.Equal(115, t.AddrP2sh);
+        Assert.Equal("tplm", t.SegwitHrp);
+        Assert.Equal(1, t.Bip44CoinType);
+
+        var r = ChainProfiles.Regtest;
+        Assert.Equal("rplm", r.SegwitHrp);
+    }
+
+    [Fact]
+    public void Selettore_di_rete_restituisce_il_profilo_giusto()
+    {
+        Assert.Same(ChainProfiles.Mainnet, ChainProfiles.For(NetKind.Mainnet));
+        Assert.Same(ChainProfiles.Testnet, ChainProfiles.For(NetKind.Testnet));
+        Assert.Same(ChainProfiles.Regtest, ChainProfiles.For(NetKind.Regtest));
+    }
+
+    [Theory]
+    [InlineData(ScriptKind.Legacy, "xprv", "xpub")]
+    [InlineData(ScriptKind.WrappedSegwit, "yprv", "ypub")]
+    [InlineData(ScriptKind.WrappedSegwitMultisig, "Yprv", "Ypub")]
+    [InlineData(ScriptKind.NativeSegwit, "zprv", "zpub")]
+    [InlineData(ScriptKind.NativeSegwitMultisig, "Zprv", "Zpub")]
+    public void Header_estesi_mainnet_producono_i_prefissi_slip132_attesi(
+        ScriptKind kind, string privPrefix, string pubPrefix)
+    {
+        var headers = ChainProfiles.Mainnet.ExtKeyHeaders[kind];
+        Assert.StartsWith(privPrefix, EncodeWithHeader(headers.Private));
+        Assert.StartsWith(pubPrefix, EncodeWithHeader(headers.Public));
+    }
+
+    [Fact]
+    public void Header_estesi_testnet_producono_tprv_tpub()
+    {
+        var headers = ChainProfiles.Testnet.ExtKeyHeaders[ScriptKind.Legacy];
+        Assert.StartsWith("tprv", EncodeWithHeader(headers.Private));
+        Assert.StartsWith("tpub", EncodeWithHeader(headers.Public));
+    }
+
+    // Serializza header (4 byte BE) + payload BIP32 di 74 byte e codifica Base58Check:
+    // il prefisso testuale risultante dipende solo dall'header.
+    private static string EncodeWithHeader(uint header)
+    {
+        var data = new byte[78];
+        data[0] = (byte)(header >> 24);
+        data[1] = (byte)(header >> 16);
+        data[2] = (byte)(header >> 8);
+        data[3] = (byte)header;
+        return Encoders.Base58Check.EncodeData(data);
+    }
+}
@@ -0,0 +1,78 @@
+using NBitcoin;
+using PalladiumWallet.Core.Chain;
+
+namespace PalladiumWallet.Tests.Chain;
+
+public class PalladiumNetworksTests
+{
+    // Chiave privata fissa per test deterministici (solo test, mai usarla davvero).
+    private static Key TestKey => new(Convert.FromHexString(
+        "0000000000000000000000000000000000000000000000000000000000000001"));
+
+    [Theory]
+    [InlineData(NetKind.Mainnet)]
+    [InlineData(NetKind.Testnet)]
+    [InlineData(NetKind.Regtest)]
+    public void La_genesi_della_rete_corrisponde_al_profilo(NetKind kind)
+    {
+        var network = PalladiumNetworks.For(kind);
+        var profile = ChainProfiles.For(kind);
+
+        Assert.Equal(profile.GenesisHash, network.GetGenesis().GetHash().ToString());
+    }
+
+    [Fact]
+    public void Indirizzo_p2pkh_mainnet_inizia_con_P()
+    {
+        var addr = TestKey.PubKey.GetAddress(ScriptPubKeyType.Legacy, PalladiumNetworks.Mainnet);
+        Assert.StartsWith("P", addr.ToString());
+    }
+
+    [Fact]
+    public void Indirizzo_native_segwit_mainnet_inizia_con_plm1()
+    {
+        var addr = TestKey.PubKey.GetAddress(ScriptPubKeyType.Segwit, PalladiumNetworks.Mainnet);
+        Assert.StartsWith("plm1", addr.ToString());
+    }
+
+    [Fact]
+    public void Indirizzo_segwit_wrapped_mainnet_inizia_con_3()
+    {
+        var addr = TestKey.PubKey.GetAddress(ScriptPubKeyType.SegwitP2SH, PalladiumNetworks.Mainnet);
+        Assert.StartsWith("3", addr.ToString());
+    }
+
+    [Theory]
+    [InlineData(NetKind.Testnet, "tplm1")]
+    [InlineData(NetKind.Regtest, "rplm1")]
+    public void Indirizzi_segwit_test_e_regtest_usano_l_hrp_giusto(NetKind kind, string prefix)
+    {
+        var addr = TestKey.PubKey.GetAddress(ScriptPubKeyType.Segwit, PalladiumNetworks.For(kind));
+        Assert.StartsWith(prefix, addr.ToString());
+    }
+
+    [Fact]
+    public void Wif_mainnet_fa_roundtrip_con_il_prefisso_del_profilo()
+    {
+        var wif = TestKey.GetWif(PalladiumNetworks.Mainnet);
+        var decoded = Key.Parse(wif.ToString(), PalladiumNetworks.Mainnet);
+
+        Assert.Equal(TestKey.ToHex(), decoded.ToHex());
+    }
+
+    [Fact]
+    public void Chiavi_estese_mainnet_serializzano_come_xprv_xpub()
+    {
+        var ext = new ExtKey();
+        Assert.StartsWith("xprv", ext.ToString(PalladiumNetworks.Mainnet));
+        Assert.StartsWith("xpub", ext.Neuter().ToString(PalladiumNetworks.Mainnet));
+    }
+
+    [Fact]
+    public void Le_tre_reti_sono_distinte_e_riutilizzate()
+    {
+        Assert.NotSame(PalladiumNetworks.Mainnet, PalladiumNetworks.Testnet);
+        Assert.NotSame(PalladiumNetworks.Testnet, PalladiumNetworks.Regtest);
+        Assert.Same(PalladiumNetworks.Mainnet, PalladiumNetworks.For(NetKind.Mainnet));
+    }
+}