Merge aa25539 into c5730d9

stellar-dotnet-sdk-test/AccountTest.cs

@@ -12,7 +12,7 @@ public void TestNullArguments()
         {
             try
             {
-                var unused = new Account(null, 10L);
+                var unused = new Account((string) null, 10L);
                 Assert.Fail();
             }
             catch (ArgumentNullException)
@@ -30,6 +30,26 @@ public void TestNullArguments()
             }
         }
 
+        [TestMethod]
+        public void TestWithStringArgumentIsKeyPair()
+        {
+            var keypair = KeyPair.Random();
+            var account = new Account(keypair.Address, 7);
+            Assert.AreEqual(account.AccountId, keypair.AccountId);
+            Assert.AreEqual(account.KeyPair.AccountId, keypair.AccountId);
+        }
+
+        [TestMethod]
+        public void TestWithMuxedAccount()
+        {
+            var keypair = KeyPair.Random();
+            var muxed = new MuxedAccountMed25519(keypair, 10);
+            var account = new Account(muxed, 7);
+            Assert.AreNotEqual(account.AccountId, keypair.AccountId);
+            Assert.AreEqual(account.AccountId, muxed.AccountId);
+            Assert.AreEqual(account.KeyPair.AccountId, keypair.AccountId);
+        }
+
         [TestMethod]
         public void TestGetIncrementedSequenceNumber()
         {

stellar-dotnet-sdk-test/FeeBumpTransactionTest.cs

@@ -0,0 +1,177 @@
+using System;
+using System.Security.Cryptography;
+using dotnetstandard_bip32;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using stellar_dotnet_sdk;
+
+namespace stellar_dotnet_sdk_test
+{
+    [TestClass]
+    public class FeeBumpTransactionTest
+    {
+        public long BaseFee { get; set; }
+        public string NetworkPassphrase { get; set; }
+        public Network Network { get; set; }
+        public KeyPair InnerSource { get; set; }
+        public Account InnerAccount { get; set; }
+        public KeyPair Destination { get; set; }
+        public string Amount { get; set; }
+        public Asset Asset { get; set; }
+        public Transaction InnerTransaction { get; set; }
+        public KeyPair FeeSource { get; set; }
+        public FeeBumpTransaction Transaction { get; set; }
+
+        [TestInitialize]
+        public void Initialize()
+        {
+            BaseFee = 100;
+            NetworkPassphrase = "Standalone Network ; February 2017";
+            Network = new Network(NetworkPassphrase);
+            InnerSource = KeyPair.FromSecretSeed(Network.NetworkId);
+            InnerAccount = new Account(InnerSource.AccountId, 7);
+            Destination = KeyPair.FromAccountId("GDQERENWDDSQZS7R7WKHZI3BSOYMV3FSWR7TFUYFTKQ447PIX6NREOJM");
+            Amount = "2000.0000000";
+            Asset = new AssetTypeNative();
+            InnerTransaction = new TransactionBuilder(InnerAccount)
+                .SetFee(100)
+                .AddTimeBounds(new TimeBounds(0, 0))
+                .AddOperation(
+                    new PaymentOperation.Builder(Destination, Asset, Amount)
+                        .Build())
+                .AddMemo(new MemoText("Happy birthday!"))
+                .Build();
+            InnerTransaction.Sign(InnerSource, Network);
+            FeeSource = KeyPair.FromSecretSeed("SB7ZMPZB3YMMK5CUWENXVLZWBK4KYX4YU5JBXQNZSK2DP2Q7V3LVTO5V");
+            Transaction = TransactionBuilder.BuildFeeBumpTransaction(FeeSource, InnerTransaction, 100);
+        }
+
+        [TestMethod]
+        public void TestLessThanInnerBaseFeeRate()
+        {
+            try
+            {
+                var transaction = TransactionBuilder.BuildFeeBumpTransaction(FeeSource, InnerTransaction, 50);
+            }
+            catch (Exception e)
+            {
+                var innerOps = InnerTransaction.Operations.Length;
+                var innerBaseFeeRate = InnerTransaction.Fee / innerOps;
+
+                Assert.AreEqual(e.Message, $"Invalid fee, it should be at least {innerBaseFeeRate} stroops");
+            }
+        }
+
+        [TestMethod]
+        public void TestLessThanBaseFee()
+        {
+            try
+            {
+                var transaction = TransactionBuilder.BuildFeeBumpTransaction(FeeSource, InnerTransaction, 50);
+            }
+            catch (Exception e)
+            {
+                Assert.AreEqual(e.Message, $"Invalid fee, it should be at least {BaseFee} stroops");
+            }
+        }
+
+        [TestMethod]
+        public void TestBuildFromTransactionEnvelope()
+        {
+            Transaction.Sign(FeeSource, Network);
+            Assert.AreEqual(FeeSource, Transaction.FeeSource);
+            Assert.AreEqual(200, Transaction.Fee);
+
+            var expectedXdr =
+                "AAAABQAAAADgSJG2GOUMy/H9lHyjYZOwyuyytH8y0wWaoc596L+bEgAAAAAAAADIAAAAAgAAAABzdv3ojkzWHMD7KUoXhrPx0GH18vHKV0ZfqpMiEblG1gAAAGQAAAAAAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAA9IYXBweSBiaXJ0aGRheSEAAAAAAQAAAAAAAAABAAAAAOBIkbYY5QzL8f2UfKNhk7DK7LK0fzLTBZqhzn3ov5sSAAAAAAAAAASoF8gAAAAAAAAAAAERuUbWAAAAQK933Dnt1pxXlsf1B5CYn81PLxeYsx+MiV9EGbMdUfEcdDWUySyIkdzJefjpR5ejdXVp/KXosGmNUQ+DrIBlzg0AAAAAAAAAAei/mxIAAABAijIIQpL6KlFefiL4FP8UWQktWEz4wFgGNSaXe7mZdVMuiREntehi1b7MRqZ1h+W+Y0y+Z2HtMunsilT2yS5mAA==";
+            Assert.AreEqual(expectedXdr, Transaction.ToEnvelopeXdrBase64());
+        }
+
+        [TestMethod]
+        public void TestSign()
+        {
+            Transaction.Sign(FeeSource, Network);
+            var xdr = Transaction.ToEnvelopeXdr();
+            Assert.AreEqual(1, xdr.FeeBump.Signatures.Length);
+            var rawSig = xdr.FeeBump.Signatures[0];
+            Assert.IsTrue(FeeSource.Verify(Transaction.Hash(Network), rawSig.Signature));
+        }
+
+        [TestMethod]
+        public void TestSignUsingPreImage()
+        {
+            var rng = RandomNumberGenerator.Create();
+            var preImage = new byte[64];
+            rng.GetBytes(preImage);
+            Transaction.Sign(preImage);
+            var xdr = Transaction.ToEnvelopeXdr();
+            var rawSig = xdr.FeeBump.Signatures[0];
+            CollectionAssert.AreEqual(preImage, rawSig.Signature.InnerValue);
+        }
+
+        [TestMethod]
+        public void TestFromEnvelopeXdr()
+        {
+            var xdr =
+                "AAAABQAAAADgSJG2GOUMy/H9lHyjYZOwyuyytH8y0wWaoc596L+bEgAAAAAAAADIAAAAAgAAAABzdv3ojkzWHMD7KUoXhrPx0GH18vHKV0ZfqpMiEblG1gAAAGQAAAAAAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAA9IYXBweSBiaXJ0aGRheSEAAAAAAQAAAAAAAAABAAAAAOBIkbYY5QzL8f2UfKNhk7DK7LK0fzLTBZqhzn3ov5sSAAAAAAAAAASoF8gAAAAAAAAAAAERuUbWAAAAQK933Dnt1pxXlsf1B5CYn81PLxeYsx+MiV9EGbMdUfEcdDWUySyIkdzJefjpR5ejdXVp/KXosGmNUQ+DrIBlzg0AAAAAAAAAAei/mxIAAABAijIIQpL6KlFefiL4FP8UWQktWEz4wFgGNSaXe7mZdVMuiREntehi1b7MRqZ1h+W+Y0y+Z2HtMunsilT2yS5mAA==";
+            var tx = TransactionBuilder.FromEnvelopeXdr(xdr);
+            Assert.AreEqual(xdr, tx.ToEnvelopeXdrBase64());
+        }
+
+        [TestMethod]
+        public void TestMuxedAccounts()
+        {
+            var muxed = new MuxedAccountMed25519(FeeSource, 0);
+            var tx = TransactionBuilder.BuildFeeBumpTransaction(muxed, InnerTransaction, 100);
+            var xdr = tx.ToUnsignedEnvelopeXdr();
+            var txMuxed = MuxedAccount.FromXdrMuxedAccount(xdr.FeeBump.Tx.FeeSource);
+            Assert.AreEqual(muxed.Address, txMuxed.Address);
+        }
+
+        [TestMethod]
+        public void TestBaseFeeOverflowsLong()
+        {
+            var network = Network.Test();
+            var innerTx = CreateInnerTransaction(100+1, network);
+            var feeSource = KeyPair.FromAccountId("GDQNY3PBOJOKYZSRMK2S7LHHGWZIUISD4QORETLMXEWXBI7KFZZMKTL3");
+            Assert.ThrowsException<OverflowException>(() =>
+            {
+                TransactionBuilder.BuildFeeBumpTransaction(feeSource, innerTx, Int64.MaxValue);
+            });
+        }
+
+        [TestMethod]
+        public void TestTransactionHash()
+        {
+            var network = Network.Test();
+            var innerTx = CreateInnerTransaction(100, network);
+
+            Assert.AreEqual(
+                "95dcf35a43a1a05bcd50f3eb148b31127829a9460dc32a17c4a7f7c4677409d4",
+                Util.BytesToHex(innerTx.Hash(network)).ToLowerInvariant());
+
+            var feeSource = KeyPair.FromAccountId("GDQNY3PBOJOKYZSRMK2S7LHHGWZIUISD4QORETLMXEWXBI7KFZZMKTL3");
+            var feeBumpTx = TransactionBuilder.BuildFeeBumpTransaction(feeSource, innerTx, 200);
+
+            Assert.AreEqual(
+                "382b1588ee8b315177a34ae96ebcaeb81c0ad3e04fee7c6b5a583b826517e1e4",
+                Util.BytesToHex(feeBumpTx.Hash(network)).ToLowerInvariant());
+        }
+
+        private Transaction CreateInnerTransaction(uint fee, Network network)
+        {
+            var source = KeyPair.FromSecretSeed("SCH27VUZZ6UAKB67BDNF6FA42YMBMQCBKXWGMFD5TZ6S5ZZCZFLRXKHS");
+            var destination =
+                MuxedAccountMed25519.FromMuxedAccountId(
+                    "MCAAAAAAAAAAAAB7BQ2L7E5NBWMXDUCMZSIPOBKRDSBYVLMXGSSKF6YNPIB7Y77ITKNOG");
+            var account = new Account(source, 2908908335136768L);
+            var innerTx = new TransactionBuilder(account)
+                .AddOperation(
+                    new PaymentOperation.Builder(destination, new AssetTypeNative(), "200.0").Build())
+                .SetFee(fee)
+                .AddTimeBounds(new TimeBounds(10, 11))
+                .Build();
+            innerTx.Sign(source, network);
+            return innerTx;
+        }
+    }
+}

stellar-dotnet-sdk-test/MuxedAccountTest.cs

@@ -0,0 +1,19 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using stellar_dotnet_sdk;
+
+namespace stellar_dotnet_sdk_test
+{
+    [TestClass]
+    public class MuxedAccountTest
+    {
+        [TestMethod]
+        public void TestFromAccountId()
+        {
+            var muxed = MuxedAccountMed25519.FromMuxedAccountId(
+                "MAAAAAAAAAAAJURAAB2X52XFQP6FBXLGT6LWOOWMEXWHEWBDVRZ7V5WH34Y22MPFBHUHY");
+            Assert.AreEqual(1234UL, muxed.Id);
+            Assert.AreEqual("GAQAA5L65LSYH7CQ3VTJ7F3HHLGCL3DSLAR2Y47263D56MNNGHSQSTVY", muxed.Key.Address);
+            Assert.AreEqual("MAAAAAAAAAAAJURAAB2X52XFQP6FBXLGT6LWOOWMEXWHEWBDVRZ7V5WH34Y22MPFBHUHY", muxed.Address);
+        }
+    }
+}