Simplifying access to Transactions and Blocks in syscalls

neo.UnitTests/SmartContract/UT_Syscalls.cs

@@ -1,14 +1,231 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
 using Neo.SmartContract;
 using Neo.VM;
+using Neo.VM.Types;
 using System.Linq;
 
 namespace Neo.UnitTests.SmartContract
 {
     [TestClass]
     public class UT_Syscalls
     {
+        [TestMethod]
+        public void Neo_Transaction_GetScript()
+        {
+            var snapshot = TestBlockchain.GetStore().GetSnapshot();
+
+            var script = new ScriptBuilder();
+            script.EmitSysCall(InteropService.Neo_Transaction_GetScript);
+
+            // With tx
+
+            var tx = new Transaction() { Script = new byte[] { 0x01 } };
+
+            var engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(tx));
+
+            Assert.AreEqual(engine.Execute(), VMState.HALT);
+            CollectionAssert.AreEqual(engine.ResultStack.Pop().GetByteArray(), tx.Script);
+
+            // Without push
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+
+            // Without tx
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(new object()));
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+        }
+
+        [TestMethod]
+        public void Neo_Transaction_GetHash()
+        {
+            var snapshot = TestBlockchain.GetStore().GetSnapshot();
+
+            var script = new ScriptBuilder();
+            script.EmitSysCall(InteropService.System_Transaction_GetHash);
+
+            // With tx
+
+            var tx = new Transaction()
+            {
+                Sender = UInt160.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
+                Attributes = new TransactionAttribute[0],
+                Cosigners = new Cosigner[0],
+                Script = new byte[0],
+                Witnesses = new Witness[0],
+            };
+
+            var engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(tx));
+
+            Assert.AreEqual(engine.Execute(), VMState.HALT);
+            CollectionAssert.AreEqual(engine.ResultStack.Pop().GetByteArray(), tx.Hash.ToArray());
+
+            // Without push
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+
+            // Without tx
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(new object()));
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+        }
+
+        [TestMethod]
+        public void Neo_Transaction_GetWitnesses()
+        {
+            var snapshot = TestBlockchain.GetStore().GetSnapshot();
+
+            var script = new ScriptBuilder();
+            script.EmitSysCall(InteropService.Neo_Transaction_GetWitnesses);
+
+            // With tx
+
+            var tx = new Transaction()
+            {
+                Witnesses = new Witness[]
+                {
+                     new Witness()
+                     {
+                         InvocationScript = new byte[] { 0x01 },
+                         VerificationScript = new byte[] { 0x02 }
+                     }
+                }
+            };
+
+            var engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(tx));
+
+            Assert.AreEqual(engine.Execute(), VMState.HALT);
+            var item = (Array)engine.ResultStack.Pop();
+            CollectionAssert.AreEqual((item[0] as InteropInterface)
+                .GetInterface<WitnessWrapper>().VerificationScript, tx.Witnesses[0].VerificationScript.ToArray());
+
+            // More than expected
+
+            tx.Witnesses = new Witness[engine.MaxArraySize + 1];
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(tx));
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+
+            // Without push
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+
+            // Without tx
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(new object()));
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+        }
+
+        [TestMethod]
+        public void Neo_Transaction_GetNonce()
+        {
+            var snapshot = TestBlockchain.GetStore().GetSnapshot();
+
+            var script = new ScriptBuilder();
+            script.EmitSysCall(InteropService.System_Transaction_GetNonce);
+
+            // With tx
+
+            var tx = new Transaction() { Nonce = 0x505152 };
+
+            var engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(tx));
+
+            Assert.AreEqual(engine.Execute(), VMState.HALT);
+            Assert.AreEqual(engine.ResultStack.Pop().GetBigInteger(), tx.Nonce);
+
+            // Without push
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+
+            // Without tx
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(new object()));
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+        }
+
+        [TestMethod]
+        public void Neo_Transaction_GetSender()
+        {
+            var snapshot = TestBlockchain.GetStore().GetSnapshot();
+
+            var script = new ScriptBuilder();
+            script.EmitSysCall(InteropService.System_Transaction_GetSender);
+
+            // With tx
+
+            var tx = new Transaction() { Sender = UInt160.Parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF") };
+
+            var engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(tx));
+
+            Assert.AreEqual(engine.Execute(), VMState.HALT);
+            CollectionAssert.AreEqual(engine.ResultStack.Pop().GetByteArray(), tx.Sender.ToArray());
+
+            // Without push
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+
+            // Without tx
+
+            engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0, true);
+            engine.LoadScript(script.ToArray());
+            engine.CurrentContext.EvaluationStack.Push(InteropInterface.FromInterface(new object()));
+
+            Assert.AreEqual(engine.Execute(), VMState.FAULT);
+            Assert.AreEqual(0, engine.ResultStack.Count);
+        }
+
         [TestMethod]
         public void System_Runtime_GetInvocationCounter()
         {

neo/SmartContract/InteropService.NEO.cs

@@ -23,8 +23,6 @@ static partial class InteropService
         public static readonly uint Neo_Header_GetVersion = Register("Neo.Header.GetVersion", Header_GetVersion, 0_00000400, TriggerType.Application);
         public static readonly uint Neo_Header_GetMerkleRoot = Register("Neo.Header.GetMerkleRoot", Header_GetMerkleRoot, 0_00000400, TriggerType.Application);
         public static readonly uint Neo_Header_GetNextConsensus = Register("Neo.Header.GetNextConsensus", Header_GetNextConsensus, 0_00000400, TriggerType.Application);
-        public static readonly uint Neo_Transaction_GetScript = Register("Neo.Transaction.GetScript", Transaction_GetScript, 0_00000400, TriggerType.All);
-        public static readonly uint Neo_Transaction_GetWitnesses = Register("Neo.Transaction.GetWitnesses", Transaction_GetWitnesses, 0_00010000, TriggerType.All);
         public static readonly uint Neo_Witness_GetVerificationScript = Register("Neo.Witness.GetVerificationScript", Witness_GetVerificationScript, 0_00000400, TriggerType.All);
         public static readonly uint Neo_Account_IsStandard = Register("Neo.Account.IsStandard", Account_IsStandard, 0_00030000, TriggerType.All);
         public static readonly uint Neo_Contract_Create = Register("Neo.Contract.Create", Contract_Create, GetDeploymentPrice, TriggerType.Application);
@@ -193,32 +191,6 @@ private static bool Header_GetNextConsensus(ApplicationEngine engine)
             return false;
         }
 
-        private static bool Transaction_GetScript(ApplicationEngine engine)
-        {
-            if (engine.CurrentContext.EvaluationStack.Pop() is InteropInterface _interface)
-            {
-                Transaction tx = _interface.GetInterface<Transaction>();
-                if (tx == null) return false;
-                engine.CurrentContext.EvaluationStack.Push(tx.Script);
-                return true;
-            }
-            return false;
-        }
-
-        private static bool Transaction_GetWitnesses(ApplicationEngine engine)
-        {
-            if (engine.CurrentContext.EvaluationStack.Pop() is InteropInterface _interface)
-            {
-                Transaction tx = _interface.GetInterface<Transaction>();
-                if (tx == null) return false;
-                if (tx.Witnesses.Length > engine.MaxArraySize)
-                    return false;
-                engine.CurrentContext.EvaluationStack.Push(WitnessWrapper.Create(tx, engine.Snapshot).Select(p => StackItem.FromInterface(p)).ToArray());
-                return true;
-            }
-            return false;
-        }
-
         private static bool Witness_GetVerificationScript(ApplicationEngine engine)
         {
             if (engine.CurrentContext.EvaluationStack.Pop() is InteropInterface _interface)

neo/SmartContract/InteropService.cs

@@ -53,7 +53,6 @@ public static partial class InteropService
         public static readonly uint System_Block_GetTransactionCount = Register("System.Block.GetTransactionCount", Block_GetTransactionCount, 0_00000400, TriggerType.Application);
         public static readonly uint System_Block_GetTransactions = Register("System.Block.GetTransactions", Block_GetTransactions, 0_00010000, TriggerType.Application);
         public static readonly uint System_Block_GetTransaction = Register("System.Block.GetTransaction", Block_GetTransaction, 0_00000400, TriggerType.Application);
-        public static readonly uint System_Transaction_GetHash = Register("System.Transaction.GetHash", Transaction_GetHash, 0_00000400, TriggerType.All);
         public static readonly uint System_Contract_Call = Register("System.Contract.Call", Contract_Call, 0_01000000, TriggerType.System | TriggerType.Application);
         public static readonly uint System_Contract_Destroy = Register("System.Contract.Destroy", Contract_Destroy, 0_01000000, TriggerType.Application);
         public static readonly uint System_Storage_GetContext = Register("System.Storage.GetContext", Storage_GetContext, 0_00000400, TriggerType.Application);
@@ -112,7 +111,14 @@ private static uint Register(string method, Func<ApplicationEngine, bool> handle
 
         private static bool ExecutionEngine_GetScriptContainer(ApplicationEngine engine)
         {
-            engine.CurrentContext.EvaluationStack.Push(StackItem.FromInterface(engine.ScriptContainer));
+            if (engine.ScriptContainer is Transaction tx)
+            {
+                engine.CurrentContext.EvaluationStack.Push(TransactionToStackItem(tx));
+            }
+            else
+            {
+                engine.CurrentContext.EvaluationStack.Push(StackItem.FromInterface(engine.ScriptContainer));
+            }
             return true;
         }
 
@@ -352,7 +358,8 @@ private static bool Blockchain_GetTransaction(ApplicationEngine engine)
         {
             byte[] hash = engine.CurrentContext.EvaluationStack.Pop().GetByteArray();
             Transaction tx = engine.Snapshot.GetTransaction(new UInt256(hash));
-            engine.CurrentContext.EvaluationStack.Push(StackItem.FromInterface(tx));
+            if (tx == null) return false;
+            engine.CurrentContext.EvaluationStack.Push(TransactionToStackItem(tx));
             return true;
         }
 
@@ -435,6 +442,25 @@ private static bool Block_GetTransactionCount(ApplicationEngine engine)
             return false;
         }
 
+        private static StackItem TransactionToStackItem(Transaction tx)
+        {
+            return new VM.Types.Array
+            (
+                new StackItem[]
+                {
+                    new ByteArray(tx.Hash.ToArray()),
+                    new ByteArray(tx.Sender.ToArray()),
+                    new ByteArray(tx.Script),
+                    new VM.Types.Array(tx.Witnesses.Select(u=>new ByteArray(u.VerificationScript))),
+                    new Integer(tx.Nonce),
+                    new Integer(tx.NetworkFee),
+                    new Integer(tx.SystemFee),
+                    new Integer(tx.ValidUntilBlock),
+                    new Integer(tx.Version)
+                }
+            );
+        }
+
         private static bool Block_GetTransactions(ApplicationEngine engine)
         {
             if (engine.CurrentContext.EvaluationStack.Pop() is InteropInterface _interface)
@@ -443,7 +469,7 @@ private static bool Block_GetTransactions(ApplicationEngine engine)
                 if (block == null) return false;
                 if (block.Transactions.Length > engine.MaxArraySize)
                     return false;
-                engine.CurrentContext.EvaluationStack.Push(block.Transactions.Select(p => StackItem.FromInterface(p)).ToArray());
+                engine.CurrentContext.EvaluationStack.Push(new VM.Types.Array(block.Transactions.Select(p => TransactionToStackItem(p))));
                 return true;
             }
             return false;
@@ -458,19 +484,7 @@ private static bool Block_GetTransaction(ApplicationEngine engine)
                 if (block == null) return false;
                 if (index < 0 || index >= block.Transactions.Length) return false;
                 Transaction tx = block.Transactions[index];
-                engine.CurrentContext.EvaluationStack.Push(StackItem.FromInterface(tx));
-                return true;
-            }
-            return false;
-        }
-
-        private static bool Transaction_GetHash(ApplicationEngine engine)
-        {
-            if (engine.CurrentContext.EvaluationStack.Pop() is InteropInterface _interface)
-            {
-                Transaction tx = _interface.GetInterface<Transaction>();
-                if (tx == null) return false;
-                engine.CurrentContext.EvaluationStack.Push(tx.Hash.ToArray());
+                engine.CurrentContext.EvaluationStack.Push(TransactionToStackItem(tx));
                 return true;
             }
             return false;