Add command to download a contract

src/neoxp/Commands/ContractCommand.Download.cs

@@ -0,0 +1,75 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using System.Net.Http;
+using System.Threading.Tasks;
+using McMaster.Extensions.CommandLineUtils;
+using Neo;
+using Neo.IO.Json;
+using Neo.Network.RPC;
+
+namespace NeoExpress.Commands
+{
+    partial class ContractCommand
+    {
+        [Command(Name = "download", Description = "Download contract with storage from remote chain into local chain")]
+        internal class Download
+        {
+            readonly ExpressChainManagerFactory chainManagerFactory;
+            private RpcClient rpcClient = null!;
+
+            public Download(ExpressChainManagerFactory chainManagerFactory)
+            {
+                this.chainManagerFactory = chainManagerFactory;
+            }
+
+            [Argument(0, Description = "Contract invocation hash")]
+            [Required]
+            internal string Contract { get; init; } = string.Empty;
+
+            [Argument(1, Description = "Source network RPC address")]
+            internal string Source { get; init; } = string.Empty;
+
+            [Option(Description = "Path to neo-express data file")]
+            internal string Input { get; init; } = string.Empty;
+
+            internal async Task ExecuteAsync(TextWriter writer)
+            {
+                var (chainManager, _) = chainManagerFactory.LoadChain(Input);
+                var expressNode = chainManager.GetExpressNode();
+
+                this.rpcClient = new RpcClient(new Uri(Source));
+
+                if (!UInt160.TryParse(Contract, out _))
+                {
+                    await writer.WriteLineAsync($"Invalid contract hash: {Contract} ").ConfigureAwait(false);
+                }
+                else
+                {
+                    // 1. Get ContractState
+                    var state = await this.rpcClient.GetContractStateAsync(Contract).ConfigureAwait(false);
+
+                    // 2. Get Full storage of the contract
+                    var storage_pairs = (JArray)await this.rpcClient.RpcSendAsync("getfullstorage", Contract).ConfigureAwait(false);
+
+                    await writer.WriteLineAsync(storage_pairs.ToString(true)).ConfigureAwait(false);
+                    await expressNode.PersistContractAsync(state, storage_pairs);
+                }
+            }
+
+            internal async Task<int> OnExecuteAsync(CommandLineApplication app, IConsole console)
+            {
+                try
+                {
+                    await ExecuteAsync(console.Out).ConfigureAwait(false);
+                    return 0;
+                }
+                catch (Exception ex)
+                {
+                    app.WriteException(ex);
+                    return 1;
+                }
+            }
+        }
+    }
+}

src/neoxp/Commands/ContractCommand.cs

@@ -3,7 +3,7 @@
 namespace NeoExpress.Commands
 {
     [Command("contract", Description = "Manage smart contracts")]
-    [Subcommand(typeof(Deploy), typeof(Get), typeof(Hash), typeof(Invoke), typeof(List), typeof(Run), typeof(Storage))]
+    [Subcommand(typeof(Deploy), typeof(Get), typeof(Hash), typeof(Invoke), typeof(List), typeof(Run), typeof(Storage), typeof(Download))]
     partial class ContractCommand
     {
         internal int OnExecute(CommandLineApplication app, IConsole console)

src/neoxp/IExpressNode.cs

@@ -4,8 +4,10 @@
 using System.Threading.Tasks;
 using Neo;
 using Neo.Cryptography.ECC;
+using Neo.IO.Json;
 using Neo.Network.P2P.Payloads;
 using Neo.Network.RPC.Models;
+using Neo.SmartContract;
 using Neo.SmartContract.Manifest;
 using Neo.SmartContract.Native;
 using Neo.VM;
@@ -39,5 +41,7 @@ enum CheckpointMode { Online, Offline }
         Task<IReadOnlyList<(ulong requestId, OracleRequest request)>> ListOracleRequestsAsync();
         Task<IReadOnlyList<ExpressStorage>> ListStoragesAsync(UInt160 scriptHash);
         Task<IReadOnlyList<TokenContract>> ListTokenContractsAsync();
+
+        Task<bool> PersistContractAsync(ContractState state, JArray storagePairs);
     }
 }

src/neoxp/Node/Modules/ExpressRpcMethods.cs

@@ -8,8 +8,10 @@
 using Neo.IO;
 using Neo.IO.Json;
 using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
 using Neo.Plugins;
 using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
 using Neo.SmartContract.Native;
 using Neo.VM;
 using Neo.Wallets;
@@ -403,6 +405,90 @@ public JObject GetNep11Properties(JArray @params)
             }
             return json;
         }
+
+        private const byte Prefix_Contract = 8;
+        private const byte Prefix_NextAvailableId = 15;
+
+        private int LastUsedContractId(DataCache snapshot)
+        {
+            StorageKey key = new KeyBuilder(NativeContract.ContractManagement.Id, Prefix_NextAvailableId);
+            StorageItem item = snapshot.TryGet(key);
+            return (int)(BigInteger)item;
+        }
+
+        private void SetLastUsedContractId(DataCache snapshot, int newId)
+        {
+            StorageKey key = new KeyBuilder(NativeContract.ContractManagement.Id, Prefix_NextAvailableId);
+            StorageItem item = snapshot.GetAndChange(key);
+            item.Set(newId);
+        }
+
+        private int GetNextAvailableId(DataCache snapshot)
+        {
+            StorageKey key = new KeyBuilder(NativeContract.ContractManagement.Id, Prefix_NextAvailableId);
+            StorageItem item = snapshot.GetAndChange(key);
+            int value = (int)(BigInteger)item;
+            item.Add(1);
+            return value;
+        }
+
+        [RpcMethod]
+        public JObject? ExpressPersistContract(JObject @params)
+        {
+            var state = @params[0]["state"];
+            var storagePairs = (JArray) @params[0]["storage"];
+            var snapshot = neoSystem.GetSnapshot();
+
+            var nef = new NefFile
+            {
+                CheckSum = (uint)state["nef"]["checksum"].AsNumber(),
+                Compiler = state["nef"]["compiler"].AsString(),
+                Source = state["nef"]["source"].AsString(),
+                Tokens = new MethodToken[0], // TODO: support parsing MethodTokens or use fix of https://github.com/neo-project/neo/issues/2674
+                Script = Convert.FromBase64String(state["nef"]["script"].AsString())
+            };
+
+            ContractManifest m = ContractManifest.FromJson(state["manifest"]);
+
+            // Our local chain might already be using the contract id of the pulled contract, we need to check for this
+            // to avoid having contracts with duplicate id's. This is important because the contract id is part of the
+            // StorageContext used with Storage syscalls and else we'll potentially override storage keys or iterate
+            // over keys that shouldn't exist for one of the contracts.
+            int contractId = (int)state["id"].AsNumber(); 
+            if (contractId <= LastUsedContractId(snapshot))
+            {
+                contractId = GetNextAvailableId(snapshot);
+            }
+            else
+            {
+                // Update available id such that a regular contract deploy will use the right next id;
+                SetLastUsedContractId(snapshot, contractId);
+            }
+
+            var c = new ContractState
+            {
+                Id = contractId,
+                Hash = UInt160.Parse(state["hash"].AsString()),
+                UpdateCounter = (ushort)state["updatecounter"].AsNumber(),
+                Nef = nef,
+                Manifest = m
+            };
+
+            StorageKey key = new KeyBuilder(NativeContract.ContractManagement.Id, Prefix_Contract).Add(c.Hash);
+            snapshot.Add(key, new StorageItem(c));
+
+            foreach (var pair in storagePairs)
+            {
+                snapshot.Add(
+                    new StorageKey { Id = c.Id, Key = Convert.FromBase64String(pair["k"].AsString())}, 
+                    new StorageItem(Convert.FromBase64String(pair["v"].AsString()))
+                );
+            }
+
+            snapshot.Commit();
+
+            return true;
+        }
 
         static readonly IReadOnlySet<string> nep11PropertyNames = new HashSet<string>
         {

src/neoxp/Node/OfflineNode.cs

@@ -11,6 +11,7 @@
 using Neo.Cryptography;
 using Neo.Cryptography.ECC;
 using Neo.IO;
+using Neo.IO.Json;
 using Neo.Ledger;
 using Neo.Network.P2P.Payloads;
 using Neo.Network.RPC;
@@ -406,5 +407,30 @@ IReadOnlyList<ExpressStorage> ListStorages(UInt160 scriptHash)
 
         public Task<IReadOnlyList<ExpressStorage>> ListStoragesAsync(UInt160 scriptHash)
             => MakeAsync(() => ListStorages(scriptHash));
+
+        private const byte Prefix_Contract = 8;
+
+        bool PersistContract(ContractState state, JArray storagePairs)
+        {
+            var snapshot = neoSystem.StoreView.CreateSnapshot();
+
+            StorageKey key = new KeyBuilder(NativeContract.ContractManagement.Id, Prefix_Contract).Add(state.Hash);
+            snapshot.Add(key, new StorageItem(state));
+
+            foreach (var pair in storagePairs)
+            {
+                snapshot.Add(
+                    new StorageKey { Id = state.Id, Key = Convert.FromBase64String(pair["k"].AsString())}, 
+                    new StorageItem(Convert.FromBase64String(pair["v"].AsString()))
+                );
+            }
+
+            snapshot.Commit();
+            return true;
+        }
+
+        public Task<bool> PersistContractAsync(ContractState state, JArray storagePairs) 
+            => MakeAsync(() => PersistContract(state, storagePairs));
+
     }
 }

src/neoxp/Node/OnlineNode.cs

@@ -328,5 +328,14 @@ public async Task<IReadOnlyList<ExpressStorage>> ListStoragesAsync(UInt160 scrip
 
             return Array.Empty<ExpressStorage>();
         }
+
+        public async Task<bool> PersistContractAsync(ContractState state, JArray storagePairs)
+        {
+            JObject o = new JObject();
+            o["state"] = state.ToJson();
+            o["storage"] = storagePairs;
+            var json = await rpcClient.RpcSendAsync("expresspersistcontract", o).ConfigureAwait(false);
+            return true;
+        }
     }
 }