Add method to convert from byte array to bigInteger

src/Neo.SmartContract.Framework/Helper.cs

@@ -23,10 +23,21 @@ public static class Helper
 
         /// <summary>
         /// Converts byte[] to BigInteger. No guarantees are assumed regarding BigInteger working range.
+        /// If it's null it will return 0
         /// Examples: [0x0a] -> 10; [0x80] -> -128; [] -> 0; [0xff00] -> 255
         /// </summary>
+        [OpCode(OpCode.DUP)]
+        [OpCode(OpCode.ISNULL)]
+        [OpCode(OpCode.JMPIFNOT, "0x05")]
+        [OpCode(OpCode.PUSH0)]
+        [OpCode(OpCode.SWAP)]
+        [OpCode(OpCode.DROP)]
         [OpCode(OpCode.CONVERT, StackItemType_Integer)]
         public extern static BigInteger ToBigInteger(this byte[] source);
+        //{
+        //    if (value == null) return 0;
+        //    return value.ToBigInteger();
+        //}
 
         /// <summary>
         /// Converts string to byte[]. Examples: "hello" -> [0x68656c6c6f]; "" -> []; "Neo" -> [0x4e656f]

tests/Neo.Compiler.MSIL.UnitTests/TestClasses/Contract_NULL.cs

@@ -54,13 +54,13 @@ public static bool IfNull(object obj)
 
         public static object NullCollationAndCollation(string code)
         {
-            return Storage.Get(code)?.ToBigInteger() ?? 123;
+            return Storage.Get(code) ?? new byte[] { 123 };
         }
 
         public static object NullCollationAndCollation2(string code)
         {
             Storage.Put(code, "111");
-            return Storage.Get(code)?.ToBigInteger() ?? 123;
+            return Storage.Get(code) ?? new byte[] { 123 };
         }
     }
 }

tests/Neo.Compiler.MSIL.UnitTests/UnitTest_NULL.cs

@@ -102,6 +102,7 @@ public void NullCollation()
                 Assert.IsTrue(str == "linux");
             }
         }
+
         [TestMethod]
         public void NullCollationAndCollation()
         {
@@ -115,13 +116,12 @@ public void NullCollationAndCollation()
                     Features = ContractFeatures.HasStorage
                 }
             });
-            {
-                var result = _testengine.ExecuteTestCaseStandard("nullCollationAndCollation", "nes");
-                var item = result.Pop() as Integer;
-                var num = item.GetInteger();
-                Assert.IsTrue(num == 123);
-            }
+
+            var result = _testengine.ExecuteTestCaseStandard("nullCollationAndCollation", "nes");
+            var item = result.Pop() as Buffer;
+            Assert.AreEqual(123, item.GetSpan()[0]);
         }
+
         [TestMethod]
         public void NullCollationAndCollation2()
         {
@@ -135,15 +135,15 @@ public void NullCollationAndCollation2()
                     Features = ContractFeatures.HasStorage
                 }
             });
-            {
-                var result = _testengine.ExecuteTestCaseStandard("nullCollationAndCollation2", "nes");
-                var item = result.Pop() as Integer;
-                var bts = System.Text.Encoding.ASCII.GetBytes("111");
-                var num = new System.Numerics.BigInteger(bts);
 
-                Assert.IsTrue(item.GetInteger() == num);
-            }
+            var result = _testengine.ExecuteTestCaseStandard("nullCollationAndCollation2", "nes");
+            var item = result.Pop() as ByteString;
+            var bts = System.Text.Encoding.ASCII.GetBytes("111");
+            var num = new System.Numerics.BigInteger(bts);
+
+            Assert.AreEqual(num, item.GetInteger());
         }
+
         [TestMethod]
         public void EqualNull()
         {

tests/Neo.SmartContract.Framework.UnitTests/HelperTest.cs

@@ -31,6 +31,41 @@ public void TestHexToBytes()
             Assert.AreEqual("0a0b0c0d0e0f", (item as ByteString).GetSpan().ToHexString());
         }
 
+        [TestMethod]
+        public void TestToBigInteger()
+        {
+            // 0
+
+            _engine.Reset();
+            var result = _engine.ExecuteTestCaseStandard("testToBigInteger", StackItem.Null);
+            Assert.AreEqual(VMState.HALT, _engine.State);
+            Assert.AreEqual(1, result.Count);
+
+            var item = result.Pop();
+            Assert.IsInstanceOfType(item, typeof(Integer));
+            Assert.AreEqual(0, item.GetInteger());
+
+            _engine.Reset();
+            result = _engine.ExecuteTestCaseStandard("testToBigInteger", new ByteString(new byte[0]));
+            Assert.AreEqual(VMState.HALT, _engine.State);
+            Assert.AreEqual(1, result.Count);
+
+            item = result.Pop();
+            Assert.IsInstanceOfType(item, typeof(Integer));
+            Assert.AreEqual(0, item.GetInteger());
+
+            // Value
+
+            _engine.Reset();
+            result = _engine.ExecuteTestCaseStandard("testToBigInteger", new ByteString(new byte[] { 123 }));
+            Assert.AreEqual(VMState.HALT, _engine.State);
+            Assert.AreEqual(1, result.Count);
+
+            item = result.Pop();
+            Assert.IsInstanceOfType(item, typeof(Integer));
+            Assert.AreEqual(123, item.GetInteger());
+        }
+
         [TestMethod]
         public void TestAssert()
         {

tests/Neo.SmartContract.Framework.UnitTests/TestClasses/Contract_Helper.cs

@@ -1,4 +1,5 @@
 using Neo.SmartContract.Framework;
+using System.Numerics;
 
 namespace Compiler.MSIL.TestClasses
 {
@@ -18,6 +19,11 @@ public static int AssertCall(bool value)
             return 5;
         }
 
+        public static BigInteger TestToBigInteger(byte[] data)
+        {
+            return data.ToBigInteger();
+        }
+
         public static void VoidAssertCall(bool value)
         {
             Assert(value == true);