Update contract without change the hash

src/neo/Ledger/ContractState.cs

@@ -6,36 +6,28 @@
 using Neo.VM.Types;
 using System;
 using System.IO;
+using System.Linq;
 using Array = Neo.VM.Types.Array;
 
 namespace Neo.Ledger
 {
     public class ContractState : ICloneable<ContractState>, ISerializable, IInteroperable
     {
         public int Id;
+        public ushort UpdateCounter;
+        public UInt160 Hash;
         public byte[] Script;
         public ContractManifest Manifest;
 
-        private UInt160 _scriptHash;
-        public UInt160 ScriptHash
-        {
-            get
-            {
-                if (_scriptHash == null)
-                {
-                    _scriptHash = Script.ToScriptHash();
-                }
-                return _scriptHash;
-            }
-        }
-
-        int ISerializable.Size => sizeof(int) + Script.GetVarSize() + Manifest.Size;
+        int ISerializable.Size => sizeof(int) + sizeof(ushort) + UInt160.Length + Script.GetVarSize() + Manifest.Size;
 
         ContractState ICloneable<ContractState>.Clone()
         {
             return new ContractState
             {
                 Id = Id,
+                UpdateCounter = UpdateCounter,
+                Hash = Hash,
                 Script = Script,
                 Manifest = Manifest.Clone()
             };
@@ -44,13 +36,17 @@ ContractState ICloneable<ContractState>.Clone()
         void ISerializable.Deserialize(BinaryReader reader)
         {
             Id = reader.ReadInt32();
+            UpdateCounter = reader.ReadUInt16();
+            Hash = reader.ReadSerializable<UInt160>();
             Script = reader.ReadVarBytes();
             Manifest = reader.ReadSerializable<ContractManifest>();
         }
 
         void ICloneable<ContractState>.FromReplica(ContractState replica)
         {
             Id = replica.Id;
+            UpdateCounter = replica.UpdateCounter;
+            Hash = replica.Hash;
             Script = replica.Script;
             Manifest = replica.Manifest.Clone();
         }
@@ -63,23 +59,37 @@ void IInteroperable.FromStackItem(StackItem stackItem)
         void ISerializable.Serialize(BinaryWriter writer)
         {
             writer.Write(Id);
+            writer.Write(UpdateCounter);
+            writer.Write(Hash);
             writer.WriteVarBytes(Script);
             writer.Write(Manifest);
         }
 
+        /// <summary>
+        /// Return true if is allowed
+        /// </summary>
+        /// <param name="targetContract">The contract that we are calling</param>
+        /// <param name="targetMethod">The method that we are calling</param>
+        /// <returns>Return true or false</returns>
+        public bool CanCall(ContractState targetContract, string targetMethod)
+        {
+            return Manifest.Permissions.Any(u => u.IsAllowed(targetContract, targetMethod));
+        }
+
         public JObject ToJson()
         {
             JObject json = new JObject();
             json["id"] = Id;
-            json["hash"] = ScriptHash.ToString();
+            json["updatecounter"] = UpdateCounter;
+            json["hash"] = Hash.ToString();
             json["script"] = Convert.ToBase64String(Script);
             json["manifest"] = Manifest.ToJson();
             return json;
         }
 
         public StackItem ToStackItem(ReferenceCounter referenceCounter)
         {
-            return new Array(referenceCounter, new StackItem[] { Script, Manifest.ToString() });
+            return new Array(referenceCounter, new StackItem[] { Id, (int)UpdateCounter, Hash.ToArray(), Script, Manifest.ToString() });
         }
     }
 }

src/neo/SmartContract/ApplicationEngine.Contract.cs

@@ -6,15 +6,12 @@
 using Neo.SmartContract.Native;
 using Neo.VM;
 using System;
-using System.Linq;
 using Array = Neo.VM.Types.Array;
 
 namespace Neo.SmartContract
 {
     partial class ApplicationEngine
     {
-        public const int MaxContractLength = 1024 * 1024;
-
         public static readonly InteropDescriptor System_Contract_Create = Register("System.Contract.Create", nameof(CreateContract), 0, CallFlags.AllowModifyStates, false);
         public static readonly InteropDescriptor System_Contract_Update = Register("System.Contract.Update", nameof(UpdateContract), 0, CallFlags.AllowModifyStates, false);
         public static readonly InteropDescriptor System_Contract_Destroy = Register("System.Contract.Destroy", nameof(DestroyContract), 0_01000000, CallFlags.AllowModifyStates, false);
@@ -28,22 +25,27 @@ partial class ApplicationEngine
         /// </summary>
         public static readonly InteropDescriptor System_Contract_CreateStandardAccount = Register("System.Contract.CreateStandardAccount", nameof(CreateStandardAccount), 0_00010000, CallFlags.None, true);
 
-        protected internal void CreateContract(byte[] script, byte[] manifest)
+        protected internal void CreateContract(byte[] nefFile, byte[] manifest)
         {
-            if (script.Length == 0 || script.Length > MaxContractLength)
-                throw new ArgumentException($"Invalid Script Length: {script.Length}");
+            if (!(ScriptContainer is Transaction tx))
+                throw new InvalidOperationException();
+            if (nefFile.Length == 0)
+                throw new ArgumentException($"Invalid NefFile Length: {nefFile.Length}");
             if (manifest.Length == 0 || manifest.Length > ContractManifest.MaxLength)
                 throw new ArgumentException($"Invalid Manifest Length: {manifest.Length}");
 
-            AddGas(StoragePrice * (script.Length + manifest.Length));
+            AddGas(StoragePrice * (nefFile.Length + manifest.Length));
 
-            UInt160 hash = script.ToScriptHash();
+            NefFile nef = nefFile.AsSerializable<NefFile>();
+            UInt160 hash = Helper.GetContractHash(tx.Sender, nef.Script);
             ContractState contract = Snapshot.Contracts.TryGet(hash);
             if (contract != null) throw new InvalidOperationException($"Contract Already Exists: {hash}");
             contract = new ContractState
             {
                 Id = Snapshot.ContractId.GetAndChange().NextId++,
-                Script = script.ToArray(),
+                UpdateCounter = 0,
+                Script = nef.Script,
+                Hash = hash,
                 Manifest = ContractManifest.Parse(manifest)
             };
 
@@ -62,42 +64,35 @@ protected internal void CreateContract(byte[] script, byte[] manifest)
                 CallContractInternal(contract, md, new Array(ReferenceCounter) { false }, CallFlags.All, ReturnTypeConvention.EnsureIsEmpty);
         }
 
-        protected internal void UpdateContract(byte[] script, byte[] manifest)
+        protected internal void UpdateContract(byte[] nefFile, byte[] manifest)
         {
-            if (script is null && manifest is null) throw new ArgumentException();
+            if (nefFile is null && manifest is null) throw new ArgumentException();
 
-            AddGas(StoragePrice * ((script?.Length ?? 0) + (manifest?.Length ?? 0)));
+            AddGas(StoragePrice * ((nefFile?.Length ?? 0) + (manifest?.Length ?? 0)));
 
-            var contract = Snapshot.Contracts.TryGet(CurrentScriptHash);
+            var contract = Snapshot.Contracts.GetAndChange(CurrentScriptHash);
             if (contract is null) throw new InvalidOperationException($"Updating Contract Does Not Exist: {CurrentScriptHash}");
 
-            if (script != null)
+            if (nefFile != null)
             {
-                if (script.Length == 0 || script.Length > MaxContractLength)
-                    throw new ArgumentException($"Invalid Script Length: {script.Length}");
-                UInt160 hash_new = script.ToScriptHash();
-                if (hash_new.Equals(CurrentScriptHash) || Snapshot.Contracts.TryGet(hash_new) != null)
-                    throw new InvalidOperationException($"Adding Contract Hash Already Exist: {hash_new}");
-                contract = new ContractState
-                {
-                    Id = contract.Id,
-                    Script = script.ToArray(),
-                    Manifest = contract.Manifest
-                };
-                contract.Manifest.Abi.Hash = hash_new;
-                Snapshot.Contracts.Add(hash_new, contract);
-                Snapshot.Contracts.Delete(CurrentScriptHash);
+                if (nefFile.Length == 0)
+                    throw new ArgumentException($"Invalid NefFile Length: {nefFile.Length}");
+
+                NefFile nef = nefFile.AsSerializable<NefFile>();
+
+                // Update script
+                contract.Script = nef.Script;
             }
             if (manifest != null)
             {
                 if (manifest.Length == 0 || manifest.Length > ContractManifest.MaxLength)
                     throw new ArgumentException($"Invalid Manifest Length: {manifest.Length}");
-                contract = Snapshot.Contracts.GetAndChange(contract.ScriptHash);
                 contract.Manifest = ContractManifest.Parse(manifest);
-                if (!contract.Manifest.IsValid(contract.ScriptHash))
-                    throw new InvalidOperationException($"Invalid Manifest Hash: {contract.ScriptHash}");
+                if (!contract.Manifest.IsValid(contract.Hash))
+                    throw new InvalidOperationException($"Invalid Manifest Hash: {contract.Hash}");
             }
-            if (script != null)
+            contract.UpdateCounter++; // Increase update counter
+            if (nefFile != null)
             {
                 ContractMethodDescriptor md = contract.Manifest.Abi.GetMethod("_deploy");
                 if (md != null)
@@ -136,22 +131,22 @@ private void CallContractInternal(UInt160 contractHash, string method, Array arg
             ContractMethodDescriptor md = contract.Manifest.Abi.GetMethod(method);
             if (md is null) throw new InvalidOperationException($"Method {method} Does Not Exist In Contract {contractHash}");
 
-            ContractManifest currentManifest = Snapshot.Contracts.TryGet(CurrentScriptHash)?.Manifest;
-            if (currentManifest != null && !currentManifest.CanCall(contract.Manifest, method))
+            ContractState currentContract = Snapshot.Contracts.TryGet(CurrentScriptHash);
+            if (currentContract?.CanCall(contract, method) == false)
                 throw new InvalidOperationException($"Cannot Call Method {method} Of Contract {contractHash} From Contract {CurrentScriptHash}");
 
             CallContractInternal(contract, md, args, flags, convention);
         }
 
         private void CallContractInternal(ContractState contract, ContractMethodDescriptor method, Array args, CallFlags flags, ReturnTypeConvention convention)
         {
-            if (invocationCounter.TryGetValue(contract.ScriptHash, out var counter))
+            if (invocationCounter.TryGetValue(contract.Hash, out var counter))
             {
-                invocationCounter[contract.ScriptHash] = counter + 1;
+                invocationCounter[contract.Hash] = counter + 1;
             }
             else
             {
-                invocationCounter[contract.ScriptHash] = 1;
+                invocationCounter[contract.Hash] = 1;
             }
 
             GetInvocationState(CurrentContext).Convention = convention;
@@ -161,11 +156,11 @@ private void CallContractInternal(ContractState contract, ContractMethodDescript
             CallFlags callingFlags = state.CallFlags;
 
             if (args.Count != method.Parameters.Length) throw new InvalidOperationException($"Method {method.Name} Expects {method.Parameters.Length} Arguments But Receives {args.Count} Arguments");
-            ExecutionContext context_new = LoadContract(contract, method.Name, flags & callingFlags);
+            ExecutionContext context_new = LoadContract(contract, method.Name, flags & callingFlags, false);
             state = context_new.GetState<ExecutionContextState>();
             state.CallingScriptHash = callingScriptHash;
 
-            if (NativeContract.IsNative(contract.ScriptHash))
+            if (NativeContract.IsNative(contract.Hash))
             {
                 context_new.EvaluationStack.Push(args);
                 context_new.EvaluationStack.Push(method.Name);

src/neo/SmartContract/ApplicationEngine.Native.cs

@@ -19,6 +19,7 @@ protected internal void DeployNativeContracts()
                 {
                     Id = contract.Id,
                     Script = contract.Script,
+                    Hash = contract.Hash, // Use the native hash
                     Manifest = contract.Manifest
                 });
                 contract.Initialize(this);

src/neo/SmartContract/ApplicationEngine.cs

@@ -175,9 +175,9 @@ public ExecutionContext LoadContract(ContractState contract, string method, Call
             ContractMethodDescriptor md = contract.Manifest.Abi.GetMethod(method);
             if (md is null) return null;
 
-            ExecutionContext context = LoadScript(contract.Script, callFlags, md.Offset);
+            ExecutionContext context = LoadScript(contract.Script, callFlags, contract.Hash, md.Offset);
 
-            if (NativeContract.IsNative(contract.ScriptHash))
+            if (NativeContract.IsNative(contract.Hash))
             {
                 if (packParameters)
                 {
@@ -202,10 +202,15 @@ public ExecutionContext LoadContract(ContractState contract, string method, Call
             return context;
         }
 
-        public ExecutionContext LoadScript(Script script, CallFlags callFlags, int initialPosition = 0)
+        public ExecutionContext LoadScript(Script script, CallFlags callFlags, UInt160 scriptHash = null, int initialPosition = 0)
         {
-            ExecutionContext context = LoadScript(script, initialPosition);
-            context.GetState<ExecutionContextState>().CallFlags = callFlags;
+            // Create and configure context
+            ExecutionContext context = CreateContext(script, initialPosition);
+            var state = context.GetState<ExecutionContextState>();
+            state.CallFlags = callFlags;
+            state.ScriptHash = scriptHash ?? ((byte[])script).ToScriptHash();
+            // Load context
+            LoadContext(context);
             return context;
         }
 

src/neo/SmartContract/Callbacks/MethodCallback.cs

@@ -19,8 +19,8 @@ public MethodCallback(ApplicationEngine engine, UInt160 hash, string method)
         {
             if (method.StartsWith('_')) throw new ArgumentException();
             this.contract = engine.Snapshot.Contracts[hash];
-            ContractManifest currentManifest = engine.Snapshot.Contracts.TryGet(engine.CurrentScriptHash)?.Manifest;
-            if (currentManifest != null && !currentManifest.CanCall(this.contract.Manifest, method))
+            ContractState currentContract = engine.Snapshot.Contracts.TryGet(engine.CurrentScriptHash);
+            if (currentContract?.CanCall(this.contract, method) == false)
                 throw new InvalidOperationException();
             this.method = this.contract.Manifest.Abi.Methods.First(p => p.Name == method);
         }
@@ -29,7 +29,7 @@ public override void LoadContext(ApplicationEngine engine, Array args)
         {
             engine.Push(args);
             engine.Push(method.Name);
-            engine.Push(contract.ScriptHash.ToArray());
+            engine.Push(contract.Hash.ToArray());
         }
     }
 }

src/neo/SmartContract/DeployedContract.cs

@@ -14,7 +14,7 @@ public DeployedContract(ContractState contract)
             if (contract is null) throw new ArgumentNullException(nameof(contract));
 
             Script = null;
-            ScriptHash = contract.ScriptHash;
+            ScriptHash = contract.Hash;
             ContractMethodDescriptor descriptor = contract.Manifest.Abi.GetMethod("verify");
             if (descriptor is null) throw new NotSupportedException("The smart contract haven't got verify method.");
 

src/neo/SmartContract/Helper.cs

@@ -15,6 +15,16 @@ public static class Helper
     {
         private const long MaxVerificationGas = 0_50000000;
 
+        public static UInt160 GetContractHash(UInt160 sender, byte[] script)
+        {
+            using var sb = new ScriptBuilder();
+            sb.Emit(OpCode.ABORT);
+            sb.EmitPush(sender);
+            sb.EmitPush(script);
+
+            return sb.ToArray().ToScriptHash();
+        }
+
         public static UInt160 GetScriptHash(this ExecutionContext context)
         {
             return context.GetState<ExecutionContextState>().ScriptHash;
@@ -170,7 +180,7 @@ internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snap
                     {
                         if (NativeContract.IsNative(hashes[i])) return false;
                         if (hashes[i] != verifiable.Witnesses[i].ScriptHash) return false;
-                        engine.LoadScript(verification, callFlags, 0);
+                        engine.LoadScript(verification, callFlags, hashes[i], 0);
                     }
 
                     engine.LoadScript(verifiable.Witnesses[i].InvocationScript, CallFlags.None);

src/neo/SmartContract/Manifest/ContractAbi.cs

@@ -11,11 +11,6 @@ public class ContractAbi
     {
         private IReadOnlyDictionary<string, ContractMethodDescriptor> methodDictionary;
 
-        /// <summary>
-        /// Hash is the script hash of the contract. It is encoded as a hexadecimal string in big-endian.
-        /// </summary>
-        public UInt160 Hash { get; set; }
-
         /// <summary>
         /// Methods is an array of Method objects which describe the details of each method in the contract.
         /// </summary>
@@ -30,7 +25,6 @@ public ContractAbi Clone()
         {
             return new ContractAbi
             {
-                Hash = Hash,
                 Methods = Methods.Select(p => p.Clone()).ToArray(),
                 Events = Events.Select(p => p.Clone()).ToArray()
             };
@@ -45,7 +39,6 @@ public static ContractAbi FromJson(JObject json)
         {
             return new ContractAbi
             {
-                Hash = UInt160.Parse(json["hash"].AsString()),
                 Methods = ((JArray)json["methods"]).Select(u => ContractMethodDescriptor.FromJson(u)).ToArray(),
                 Events = ((JArray)json["events"]).Select(u => ContractEventDescriptor.FromJson(u)).ToArray()
             };
@@ -61,7 +54,6 @@ public ContractMethodDescriptor GetMethod(string name)
         public JObject ToJson()
         {
             var json = new JObject();
-            json["hash"] = Hash.ToString();
             json["methods"] = new JArray(Methods.Select(u => u.ToJson()).ToArray());
             json["events"] = new JArray(Events.Select(u => u.ToJson()).ToArray());
             return json;