Update contract without change the hash

src/neo/Ledger/ContractState.cs

@@ -13,29 +13,20 @@ namespace Neo.Ledger
     public class ContractState : ICloneable<ContractState>, ISerializable, IInteroperable
     {
         public int Id;
+        public ushort Version;
+        public UInt160 ScriptHash;
         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,
+                Version = Version,
+                ScriptHash = ScriptHash,
                 Script = Script,
                 Manifest = Manifest.Clone()
             };
@@ -44,13 +35,17 @@ ContractState ICloneable<ContractState>.Clone()
         void ISerializable.Deserialize(BinaryReader reader)
         {
             Id = reader.ReadInt32();
+            Version = reader.ReadUInt16();
+            ScriptHash = reader.ReadSerializable<UInt160>();
             Script = reader.ReadVarBytes();
             Manifest = reader.ReadSerializable<ContractManifest>();
         }
 
         void ICloneable<ContractState>.FromReplica(ContractState replica)
         {
             Id = replica.Id;
+            Version = replica.Version;
+            ScriptHash = replica.ScriptHash;
             Script = replica.Script;
             Manifest = replica.Manifest.Clone();
         }
@@ -63,6 +58,8 @@ void IInteroperable.FromStackItem(StackItem stackItem)
         void ISerializable.Serialize(BinaryWriter writer)
         {
             writer.Write(Id);
+            writer.Write(Version);
+            writer.Write(ScriptHash);
             writer.WriteVarBytes(Script);
             writer.Write(Manifest);
         }
@@ -71,6 +68,7 @@ public JObject ToJson()
         {
             JObject json = new JObject();
             json["id"] = Id;
+            json["version"] = Version;
             json["hash"] = ScriptHash.ToString();
             json["script"] = Convert.ToBase64String(Script);
             json["manifest"] = Manifest.ToJson();
@@ -79,7 +77,7 @@ public JObject ToJson()
 
         public StackItem ToStackItem(ReferenceCounter referenceCounter)
         {
-            return new Array(referenceCounter, new StackItem[] { Script, Manifest.ToString() });
+            return new Array(referenceCounter, new StackItem[] { Id, (int)Version, ScriptHash.ToArray(), Script, Manifest.ToString() });
         }
     }
 }

src/neo/SmartContract/ApplicationEngine.Contract.cs

@@ -28,22 +28,28 @@ 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 (nefFile.Length == 0 || nefFile.Length > NefFile.MaxLength)
+                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>();
+            if (nef.Script.Length == 0 || nef.Script.Length > MaxContractLength)
+                throw new ArgumentException($"Invalid Script Length: {nef.Script.Length}");
+
+            UInt160 hash = nefFile.ToScriptHash();
             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(),
+                Version = 0,
+                Script = nef.Script,
+                ScriptHash = hash,
                 Manifest = ContractManifest.Parse(manifest)
             };
 
@@ -62,42 +68,37 @@ 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 || nefFile.Length > NefFile.MaxLength)
+                    throw new ArgumentException($"Invalid NefFile Length: {nefFile.Length}");
+
+                NefFile nef = nefFile.AsSerializable<NefFile>();
+                if (nef.Script.Length == 0 || nef.Script.Length > MaxContractLength)
+                    throw new ArgumentException($"Invalid Script Length: {nef.Script.Length}");
+
+                // 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 (script != null)
+            contract.Version++; // Increase the version
+            if (nefFile != null)
             {
                 ContractMethodDescriptor md = contract.Manifest.Abi.GetMethod("_deploy");
                 if (md != null)
@@ -161,10 +162,9 @@ 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 = LoadScript(contract.Script, method.Offset);
+            ExecutionContext context_new = LoadScript(contract.Script, flags & callingFlags, contract.ScriptHash, method.Offset);
             state = context_new.GetState<ExecutionContextState>();
             state.CallingScriptHash = callingScriptHash;
-            state.CallFlags = flags & callingFlags;
 
             if (NativeContract.IsNative(contract.ScriptHash))
             {
@@ -178,7 +178,7 @@ private void CallContractInternal(ContractState contract, ContractMethodDescript
             }
 
             method = contract.Manifest.Abi.GetMethod("_initialize");
-            if (method != null) LoadContext(context_new.Clone(method.Offset));
+            if (method != null) LoadClonedContext(context_new, method.Offset, false);
         }
 
         protected internal bool IsStandardContract(UInt160 hash)

src/neo/SmartContract/ApplicationEngine.Native.cs

@@ -19,6 +19,7 @@ protected internal void DeployNativeContracts()
                 {
                     Id = contract.Id,
                     Script = contract.Script,
+                    ScriptHash = contract.Hash, // Not NefHash here
                     Manifest = contract.Manifest
                 });
                 contract.Initialize(this);

src/neo/SmartContract/ApplicationEngine.cs

@@ -161,17 +161,29 @@ protected override void LoadContext(ExecutionContext context)
             base.LoadContext(context);
         }
 
-        internal void LoadContext(ExecutionContext context, bool checkReturnValue)
+        internal protected void LoadClonedContext(ExecutionContext context, int initialPosition, bool checkReturnValue)
         {
+            // Copy script hash
+            var state = context.GetState<ExecutionContextState>();
+            context = context.Clone(initialPosition);
+            var newState = context.GetState<ExecutionContextState>();
+            newState.CallFlags = state.CallFlags;
+            newState.ScriptHash = state.ScriptHash;
+            // Configure CurrentContext and load the cloned one
             if (checkReturnValue)
                 GetInvocationState(CurrentContext).Convention = ReturnTypeConvention.EnsureNotEmpty;
             LoadContext(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/PointerCallback.cs

@@ -19,7 +19,7 @@ public PointerCallback(ExecutionContext context, Pointer pointer, int parameters
 
         public override void LoadContext(ApplicationEngine engine, Array args)
         {
-            engine.LoadContext(context.Clone(pointer), true);
+            engine.LoadClonedContext(context, pointer, true);
             for (int i = args.Count - 1; i >= 0; i--)
                 engine.Push(args[i]);
         }

src/neo/SmartContract/Helper.cs

@@ -177,7 +177,7 @@ internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snap
                 using (ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, verifiable, snapshot?.Clone(), gas))
                 {
                     CallFlags callFlags = verifiable.Witnesses[i].StateDependent ? CallFlags.AllowStates : CallFlags.None;
-                    ExecutionContext context = engine.LoadScript(verification, callFlags, offset);
+                    ExecutionContext context = engine.LoadScript(verification, callFlags, hashes[i], offset);
                     if (NativeContract.IsNative(hashes[i]))
                     {
                         using ScriptBuilder sb = new ScriptBuilder();
@@ -187,7 +187,7 @@ internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snap
                     }
                     else if (init != null)
                     {
-                        engine.LoadContext(context.Clone(init.Offset), false);
+                        engine.LoadClonedContext(context, init.Offset, false);
                     }
                     engine.LoadScript(verifiable.Witnesses[i].InvocationScript, CallFlags.None);
                     if (engine.Execute() == VMState.FAULT) return false;

src/neo/SmartContract/Manifest/ContractManifest.cs

@@ -15,7 +15,7 @@ public class ContractManifest : ISerializable
         /// <summary>
         /// Max length for a valid Contract Manifest
         /// </summary>
-        public const int MaxLength = 4096;
+        public const int MaxLength = ushort.MaxValue;
 
         /// <summary>
         /// Serialized size

src/neo/SmartContract/NefFile.cs

@@ -57,6 +57,8 @@ public class NefFile : ISerializable
             (sizeof(int) * 4) + // Version
             UInt160.Length;     // ScriptHash
 
+        public static readonly int MaxLength = HeaderSize + sizeof(uint) + IO.Helper.GetVarSize(1024 * 1024) + (1024 * 1024);
+
         public int Size =>
             HeaderSize +        // Header
             sizeof(uint) +      // Checksum

src/neo/Wallets/Wallet.cs

@@ -400,8 +400,8 @@ public long CalculateNetworkFee(StoreView snapshot, Transaction tx)
                     if (verify is null) throw new ArgumentException($"The smart contract {contract.ScriptHash} haven't got verify method");
                     ContractMethodDescriptor init = contract.Manifest.Abi.GetMethod("_initialize");
                     using ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, tx, snapshot.Clone());
-                    ExecutionContext context = engine.LoadScript(contract.Script, CallFlags.None, verify.Offset);
-                    if (init != null) engine.LoadContext(context.Clone(init.Offset), false);
+                    ExecutionContext context = engine.LoadScript(contract.Script, CallFlags.None, contract.ScriptHash, verify.Offset);
+                    if (init != null) engine.LoadClonedContext(context, init.Offset, false);
                     engine.LoadScript(Array.Empty<byte>(), CallFlags.None);
                     if (engine.Execute() == VMState.FAULT) throw new ArgumentException($"Smart contract {contract.ScriptHash} verification fault.");
                     if (engine.ResultStack.Count != 1 || !engine.ResultStack.Pop().GetBoolean()) throw new ArgumentException($"Smart contract {contract.ScriptHash} returns false.");

src/neo/neo.csproj

@@ -28,7 +28,7 @@
     <PackageReference Include="Microsoft.AspNetCore.WebSockets" Version="2.2.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.1.3" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="3.1.3" />
-    <PackageReference Include="Neo.VM" Version="3.0.0-CI00251" />
+    <PackageReference Include="Neo.VM" Version="3.0.0-CI00252" />
   </ItemGroup>
 
 </Project>

tests/neo.UnitTests/Ledger/UT_ContractState.cs

@@ -23,6 +23,7 @@ public void TestSetup()
             contract = new ContractState
             {
                 Script = script,
+                ScriptHash = script.ToScriptHash(),
                 Manifest = manifest
             };
         }
@@ -72,7 +73,7 @@ public void TestDeserialize()
         public void TestGetSize()
         {
             ISerializable newContract = contract;
-            newContract.Size.Should().Be(218);
+            newContract.Size.Should().Be(287);
         }
 
         [TestMethod]

tests/neo.UnitTests/SmartContract/Callbacks/UT_MethodCallback.cs

@@ -41,6 +41,7 @@ public void GetHashData()
                     },
                 },
                 Script = new byte[] { 1, 2, 3 },
+                ScriptHash = new byte[] { 1, 2, 3 }.ToScriptHash()
             };
             contract.Manifest.Abi.Hash = contract.ScriptHash;
             engine.LoadScript(contract.Script);

tests/neo.UnitTests/SmartContract/UT_DeployedContract.cs

@@ -27,7 +27,8 @@ public void TestGetAddress()
                          }
                     }
                 },
-                Script = new byte[] { 1, 2, 3 }
+                Script = new byte[] { 1, 2, 3 },
+                ScriptHash = new byte[] { 1, 2, 3 }.ToScriptHash()
             });
 
             Assert.AreEqual("0xb2e3fe334830b4741fa5d762f2ab36b90b86c49b", contract.ScriptHash.ToString());