Feature/contract call

Assets/SequenceSDK/Ethereum/Tests/ABIRegexTests.cs

@@ -0,0 +1,41 @@
+using NUnit.Framework;
+using Sequence.Contracts;
+using Assert = UnityEngine.Assertions.Assert;
+
+namespace Sequence.Ethereum.Tests
+{
+    public class ABIRegexTests
+    {
+        [TestCase("", false)]
+        [TestCase("functionName", true)]
+        [TestCase("functionName()", false)]
+        [TestCase("functionName123", true)]
+        [TestCase("functionName_s", true)]
+        [TestCase("function-Name", true)]
+        [TestCase("functionName ", false)]
+        public void TestMatchesFunctionName(string input, bool expected)
+        {
+            bool result = ABIRegex.MatchesFunctionName(input);
+            Assert.AreEqual(expected, result);
+        }
+
+        [TestCase("", false)]
+        [TestCase("functionName", false)]
+        [TestCase("functionName(", false)]
+        [TestCase("functionName()", true)]
+        [TestCase("functionName(a)", true)]
+        [TestCase("functionName(a a)", false)]
+        [TestCase("functionName(a, a)", true)]
+        [TestCase("functionName(a,a)", true)]
+        [TestCase("functionName(,)", false)]
+        [TestCase("functionName(Aa123)", true)]
+        [TestCase("functionName(a,)", false)]
+        [TestCase("functionName() ", false)]
+        [TestCase("function_-123Name()", true)]
+        public void TestMatchesFunctionABI(string input, bool expected)
+        {
+            bool result = ABIRegex.MatchesFunctionABI(input);
+            Assert.AreEqual(expected, result);
+        }
+    }
+}

Assets/SequenceSDK/Ethereum/Tests/ContractIntegrationTests.cs

@@ -93,5 +93,121 @@ public async Task TestComplexContract()
             CollectionAssert.AreEqual(expectedMoreBytes.Data, (byte[])resultPart2[3]);
             CollectionAssert.AreEqual(expectedAddresses, resultPart2[4].ConvertToTArray<Address, object>());
         }
+
+        [Test]
+        public void TestInvalidRegex_noABI()
+        {
+            Contract complexContract = new Contract(complexContractAddress);
+
+            try
+            {
+                complexContract.QueryContract<string>("functionName");
+                Assert.Fail("Expected exception but none was thrown");
+            }
+            catch (ArgumentException e)
+            {
+
+            }
+            catch (Exception e)
+            {
+                Assert.Fail("Expected argument exception");
+            }
+
+            try
+            {
+                complexContract.QueryContract<string>("functionName(");
+                Assert.Fail("Expected exception but none was thrown");
+            }
+            catch (ArgumentException e)
+            {
+
+            }
+            catch (Exception e)
+            {
+                Assert.Fail("Expected argument exception");
+            }
+
+            try
+            {
+                complexContract.QueryContract<string>("functionName)");
+                Assert.Fail("Expected exception but none was thrown");
+            }
+            catch (ArgumentException e)
+            {
+
+            }
+            catch (Exception e)
+            {
+                Assert.Fail("Expected argument exception");
+            }
+
+            try
+            {
+                complexContract.AssembleCallData("functionName(uint banana)", 1);
+            }
+            catch (Exception e)
+            {
+                Assert.Fail("No exception expected");
+            }
+
+
+            try
+            {
+                complexContract.CallFunction("functionName(uint, uint)", 1, 1);
+            }
+            catch (Exception e)
+            {
+                Assert.Fail("No exception expected");
+            }
+        }
+
+        [Test]
+        public void TestInvalidRegex_withABI()
+        {
+            Contract complexContract = new Contract(complexContractAddress, complexContractAbi);
+
+            try
+            {
+                complexContract.QueryContract<string>("functionName()");
+                Assert.Fail("Expected exception but none was thrown");
+            }
+            catch (ArgumentException e)
+            {
+
+            }
+            catch (Exception e)
+            {
+                Assert.Fail("Expected argument exception");
+            }
+
+            try
+            {
+                complexContract.AssembleCallData("functionName(uint banana)");
+                Assert.Fail("Expected exception but none was thrown");
+            }
+            catch (ArgumentException e)
+            {
+
+            }
+            catch (Exception e)
+            {
+                Assert.Fail("Expected argument exception");
+            }
+
+
+            try
+            {
+                complexContract.CallFunction("functionName*");
+                Assert.Fail("Expected exception but none was thrown");
+            }
+            catch (ArgumentException e)
+            {
+
+            }
+            catch (Exception e)
+            {
+                Assert.Fail("Expected argument exception");
+            }
+        }
     }
 }

Assets/SequenceSDK/Ethereum/Tests/WalletTests.cs

@@ -178,7 +178,7 @@ public async Task TestChain_ERC20Mock_MockMint_Test()
                 EOAWallet wallet2 = new EOAWallet("0xabc0000000000000000000000000000000000000000000000000000000000002");
                 Contract mockERC20 = new Contract(receipt.contractAddress);
                 string result = await mockERC20.SendTransactionMethod(wallet2, client, 0,
-                    "mockMint(address , uint256)",
+                    "mockMint(address, uint256)",
                     wallet2.GetAddress(), 1);
                 Assert.IsNotNull(result);
             }

Assets/SequenceSDK/WaaS/Tests/DelayedEncodeJsonSerializationTest.cs

@@ -52,5 +52,23 @@ public void TestDelayedEncodeDataArgsGetsSerializedAlphabetically()
 
             Assert.AreEqual("{\"abi\":\"testAbi(string,ComplexObjectInNonAlphabeticalOrder,int)\",\"args\":[\"some string\",{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"},1,5,[1,{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"},null,\"banana\"],[{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"},null],[1,[2,{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"},3,{\"ComplexObjectArray\":[null,{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"}],\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"}],\"word\"]],\"func\":\"testFunc\"}", json);
         }
+
+        [Test]
+        public void TestAbiDataArgsGetsSerializedAlphabetically()
+        {
+            AbiData testData = new AbiData("testAbi(string,ComplexObjectInNonAlphabeticalOrder,int)", 
+                new object[] { "some string", new ComplexObjectInNonAlphabeticalOrder("last", "first", "halfway"), 
+                    BigInteger.One, 5, new object[] { 1, new ComplexObjectInNonAlphabeticalOrder("last", "first", "halfway"), null, "banana" },
+                    new ComplexObjectInNonAlphabeticalOrder[] { new ("last", "first", "halfway"), null },
+                    new object[] { 1, new object[] { 2, new ComplexObjectInNonAlphabeticalOrder("last", "first", "halfway"), 3, 
+                        new ExtraComplexObjectWithComplexObjectArray("last", new ComplexObjectInNonAlphabeticalOrder[] { null, 
+                            new ("last", "first", "halfway")}, "halfway")}, "word"}
+                });
+
+            string json = JsonConvert.SerializeObject(testData);
+            Debug.Log(json);
+
+            Assert.AreEqual("{\"abi\":\"testAbi(string,ComplexObjectInNonAlphabeticalOrder,int)\",\"args\":[\"some string\",{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"},1,5,[1,{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"},null,\"banana\"],[{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"},null],[1,[2,{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"},3,{\"ComplexObjectArray\":[null,{\"FirstValue\":\"first\",\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"}],\"HalfwayValue\":\"halfway\",\"LastValue\":\"last\"}],\"word\"]]}", json);
+        }
     }
 }

Assets/SequenceSDK/WaaS/Tests/WaaSWalletUnitTests.cs

@@ -29,7 +29,7 @@ public async Task TestSendTransactionSuccessEvent()
                 failedEventHit = true;
             };
 
-            await wallet.SendTransaction(Chain.None, null);
+            await wallet.SendTransaction(Chain.None, Array.Empty<Transaction>());
 
             Assert.IsTrue(successEventHit);
             Assert.IsFalse(failedEventHit);
@@ -52,12 +52,117 @@ public async Task TestSendTransactionFailedEvent()
                 failedEventHit = true;
             };
 
-            await wallet.SendTransaction(Chain.None, null);
+            await wallet.SendTransaction(Chain.None, Array.Empty<Transaction>());
 
             Assert.IsFalse(successEventHit);
             Assert.IsTrue(failedEventHit);
         }
 
+        private static (DelayedEncodeData, bool)[] _invalidDelayedEncodeData = new[]
+        {
+            (new DelayedEncodeData("functionName", Array.Empty<object>(), "functionName"), false),
+            (new DelayedEncodeData("functionName()", Array.Empty<object>(), "functionName"), true),
+            (new DelayedEncodeData("functionName()", Array.Empty<object>(), "functionName()"), false),
+            (new DelayedEncodeData("functionName(", Array.Empty<object>(), "functionName"), false),
+            (new DelayedEncodeData("functionName)", Array.Empty<object>(), "functionName"), false),
+            (new DelayedEncodeData("functionName(uint banana)", new object[] {1}, "functionName"), true),
+            (new DelayedEncodeData("functionName(uint, uint)", new object[]{1,2}, "functionName"), true),
+            (new DelayedEncodeData("functionName(uint,uint)", new object[]{1,2}, "functionName(uint,uint)"), false),
+            (new DelayedEncodeData("functionName(uint banana", new object[] {1}, "functionName"), false),
+            (new DelayedEncodeData("functionNameuint, uint)", new object[]{1,2}, "functionName"), false),
+            (new DelayedEncodeData("functionName(uint,uint", new object[]{1,2}, "functionName"), false)
+        };
+
+        [TestCaseSource(nameof(_invalidDelayedEncodeData))]
+        public async Task TestSendTransactionEvent_delayedEncodeValidation((DelayedEncodeData, bool) args)
+        {
+            DelayedEncodeData data = args.Item1;
+            bool success = args.Item2;
+            IIntentSender intentSender = new MockIntentSender(new SuccessfulTransactionReturn());
+            SequenceWallet wallet = new SequenceWallet(address, "", intentSender);
+
+            bool successEventHit = false;
+            wallet.OnSendTransactionComplete += (result)=>
+            {
+                successEventHit = true;
+            };
+            bool failedEventHit = false;
+            wallet.OnSendTransactionFailed += (result)=>
+            {
+                failedEventHit = true;
+            };
+
+            await wallet.SendTransaction(Chain.None, new Transaction[]
+            {
+                new RawTransaction("0xc683a014955b75F5ECF991d4502427c8fa1Aa249"),
+                new DelayedEncode("0xc683a014955b75F5ECF991d4502427c8fa1Aa249", "0", data),
+                new RawTransaction("0xc683a014955b75F5ECF991d4502427c8fa1Aa249")
+            }, waitForReceipt: false);
+
+            if (!success)
+            {
+                Assert.IsFalse(successEventHit);
+                Assert.IsTrue(failedEventHit);
+            }
+            else
+            {
+                Assert.IsTrue(successEventHit);
+                Assert.IsFalse(failedEventHit);
+            }
+        }
+
+        private static (AbiData, bool)[] _invalidContractCallData = new[]
+        {
+            (new AbiData("functionName", Array.Empty<object>()), false),
+            (new AbiData("functionName()", Array.Empty<object>()), true),
+            (new AbiData("functionName(", Array.Empty<object>()), false),
+            (new AbiData("functionName)", Array.Empty<object>()), false),
+            (new AbiData("functionName(uint banana)", new object[] {1}), true),
+            (new AbiData("functionName(uint, uint)", new object[]{1,2}), true),
+            (new AbiData("functionName(uint,uint)", new object[]{1,2}), true),
+            (new AbiData("functionName(uint banana", new object[] {1}), false),
+            (new AbiData("functionNameuint, uint)", new object[]{1,2}), false),
+            (new AbiData("functionName(uint,uint", new object[]{1,2}), false)
+        };
+
+        [TestCaseSource(nameof(_invalidContractCallData))]
+        public async Task TestSendTransactionEvent_contractCallValidation((AbiData, bool) args)
+        {
+            AbiData data = args.Item1;
+            bool success = args.Item2;
+            IIntentSender intentSender = new MockIntentSender(new SuccessfulTransactionReturn());
+            SequenceWallet wallet = new SequenceWallet(address, "", intentSender);
+
+            bool successEventHit = false;
+            wallet.OnSendTransactionComplete += (result)=>
+            {
+                successEventHit = true;
+            };
+            bool failedEventHit = false;
+            wallet.OnSendTransactionFailed += (result)=>
+            {
+                failedEventHit = true;
+            };
+
+            await wallet.SendTransaction(Chain.None, new Transaction[]
+            {
+                new RawTransaction("0xc683a014955b75F5ECF991d4502427c8fa1Aa249"),
+                new SequenceContractCall("0xc683a014955b75F5ECF991d4502427c8fa1Aa249", data),
+                new RawTransaction("0xc683a014955b75F5ECF991d4502427c8fa1Aa249")
+            }, waitForReceipt: false);
+
+            if (!success)
+            {
+                Assert.IsFalse(successEventHit);
+                Assert.IsTrue(failedEventHit);
+            }
+            else
+            {
+                Assert.IsTrue(successEventHit);
+                Assert.IsFalse(failedEventHit);
+            }
+        }
+
         [Test]
         public async Task TestSendTransactionException()
         {
@@ -75,7 +180,7 @@ public async Task TestSendTransactionException()
                 failedEventHit = true;
             };
 
-            await wallet.SendTransaction(Chain.None, null);
+            await wallet.SendTransaction(Chain.None, Array.Empty<Transaction>());
 
             Assert.IsFalse(successEventHit);
             Assert.IsTrue(failedEventHit);
@@ -343,7 +448,7 @@ public async Task TestWaitForTransactionReceipt(int numberOfFetches)
                 failedEventHit = true;
             };
 
-            var result = await wallet.SendTransaction(Chain.None, null);
+            var result = await wallet.SendTransaction(Chain.None, Array.Empty<Transaction>());
 
             Assert.IsTrue(successEventHit);
             Assert.IsFalse(failedEventHit);
@@ -392,7 +497,7 @@ public async Task TestWaitForTransactionReceipt_failedToFetch()
 
             LogAssert.Expect(LogType.Error, "Transaction was successful, but we're unable to obtain the transaction hash. Reason: some random error");
 
-            var result = await wallet.SendTransaction(Chain.None, null);
+            var result = await wallet.SendTransaction(Chain.None, Array.Empty<Transaction>());
 
             Assert.IsTrue(successEventHit);
             Assert.IsFalse(failedEventHit);
@@ -438,7 +543,7 @@ public async Task TestDontWaitForTransactionReceipt(int numberOfFetches)
                 failedEventHit = true;
             };
 
-            var result = await wallet.SendTransaction(Chain.None, null, false);
+            var result = await wallet.SendTransaction(Chain.None, Array.Empty<Transaction>(), false);
 
             Assert.IsTrue(successEventHit);
             Assert.IsFalse(failedEventHit);