Add command to download a contract

src/neoxp/Commands/ContractCommand.Download.cs

@@ -0,0 +1,76 @@
+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;
+
+            public Download(ExpressChainManagerFactory chainManagerFactory)
+            {
+                this.chainManagerFactory = chainManagerFactory;
+            }
+
+            [Argument(0, Description = "Contract invocation hash")]
+            [Required]
+            internal string Contract { get; init; } = string.Empty;
+
+            [Argument(1, Description = "URL of Neo JSON-RPC Node\nSpecify MainNet (default), TestNet or JSON-RPC URL")]
+            internal string RpcUri { get; } = 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();
+
+                if (!UInt160.TryParse(Contract, out var contractHash))
+                    throw new ArgumentException($"Invalid contract hash: \"{Contract}\"");
+
+                if (!TransactionExecutor.TryParseRpcUri(RpcUri, out var uri))
+                    throw new ArgumentException($"Invalid RpcUri value \"{RpcUri}\"");
+
+                using var rpcClient = new RpcClient(uri);
+                var stateAPI = new StateAPI(rpcClient);
+
+                var stateHeight = await stateAPI.GetStateHeightAsync();
+                if (stateHeight.localRootIndex is null)
+                    throw new Exception("Null \"localRootIndex\" in state height response");
+                var stateRoot = await stateAPI.GetStateRootAsync(stateHeight.localRootIndex.Value);
+                var states = await stateAPI.FindStatesAsync(stateRoot.RootHash, contractHash, new byte[0]);
+
+                var contractState = await rpcClient.GetContractStateAsync(Contract).ConfigureAwait(false);
+
+                await expressNode.PersistContractAsync(contractState, states.Results);
+
+            }
+
+            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(Download), typeof(Get), typeof(Hash), typeof(Invoke), typeof(List), typeof(Run), typeof(Storage))]
     partial class ContractCommand
     {
         internal int OnExecute(CommandLineApplication app, IConsole console)

src/neoxp/IExpressNode.cs

@@ -6,6 +6,7 @@
 using Neo.Cryptography.ECC;
 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 +40,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, (byte[] key, byte[] value)[] storagePairs);
     }
 }

src/neoxp/Node/ExpressOracle.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 using Neo;
 using Neo.BlockchainToolkit.Models;
 using Neo.Cryptography.ECC;
@@ -138,5 +139,61 @@ public static void SignOracleResponseTransaction(ProtocolSettings settings, Expr
 
             return tx;
         }
+
+        public const byte Prefix_Contract = 8;
+        private const byte Prefix_NextAvailableId = 15;
+
+        private static int LastUsedContractId(DataCache snapshot)
+        {
+            StorageKey key = new KeyBuilder(NativeContract.ContractManagement.Id, Prefix_NextAvailableId);
+            StorageItem item = snapshot.TryGet(key);
+            return (int)(BigInteger)item;
+        }
+
+        private static void SetLastUsedContractId(DataCache snapshot, int newId)
+        {
+            StorageKey key = new KeyBuilder(NativeContract.ContractManagement.Id, Prefix_NextAvailableId);
+            StorageItem item = snapshot.GetAndChange(key);
+            item.Set(newId);
+        }
+
+        private static 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;
+        }
+
+        public static bool PersistContract(SnapshotCache snapshot, ContractState state, (byte[] key, byte[] value)[] storagePairs)
+        {
+            // 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.
+            if (state.Id <= LastUsedContractId(snapshot))
+            {
+                state.Id = GetNextAvailableId(snapshot);
+            }
+            else
+            {
+                // Update available id such that a regular contract deploy will use the right next id;
+                SetLastUsedContractId(snapshot, state.Id);
+            }
+
+            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 = pair.key}, 
+                    new StorageItem(pair.value)
+                );
+            }
+            snapshot.Commit();
+            return true;
+        }
     }
 }

src/neoxp/Node/Modules/ExpressRpcMethods.cs

@@ -3,18 +3,24 @@
 using System.Linq;
 using System.Numerics;
 using System.Threading;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Neo;
 using Neo.BlockchainToolkit.Persistence;
 using Neo.IO;
 using Neo.IO.Json;
 using Neo.Network.P2P.Payloads;
+using Neo.Network.RPC;
+using Neo.Persistence;
 using Neo.Plugins;
 using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
 using Neo.SmartContract.Native;
 using Neo.VM;
 using Neo.Wallets;
 using NeoExpress.Models;
 using ByteString = Neo.VM.Types.ByteString;
+using RpcException = Neo.Plugins.RpcException;
+using Utility = Neo.Utility;
 
 namespace NeoExpress.Node
 {
@@ -403,6 +409,24 @@ public JObject GetNep11Properties(JArray @params)
             }
             return json;
         }
+
+        [RpcMethod]
+        public JObject? ExpressPersistContract(JObject @params)
+        {
+
+            var state = RpcClient.ContractStateFromJson(@params[0]["state"]);
+            var storagePairs = new (byte[] Key, byte[] value)[0];
+
+            foreach (var pair in (JArray)@params[0]["storage"])
+            {
+                storagePairs.Append((
+                    Convert.FromBase64String(pair["key"].AsString()),
+                    Convert.FromBase64String(pair["value"].AsString())
+                    ));
+            }
+
+            return ExpressOracle.PersistContract(neoSystem.GetSnapshot(), state, storagePairs);
+        }
 
         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;
@@ -103,7 +104,7 @@ Task<T> MakeAsync<T>(Func<T> func)
                 return Task.FromException<T>(ex);
             }
         }
-
+        
         IExpressNode.CheckpointMode CreateCheckpoint(string checkPointPath)
         {
             var multiSigAccount = nodeWallet.GetMultiSigAccounts().Single();
@@ -406,5 +407,14 @@ IReadOnlyList<ExpressStorage> ListStorages(UInt160 scriptHash)
 
         public Task<IReadOnlyList<ExpressStorage>> ListStoragesAsync(UInt160 scriptHash)
             => MakeAsync(() => ListStorages(scriptHash));
+
+        bool PersistContract(ContractState state, (byte[] key, byte[] value)[] storagePairs)
+        {
+            return ExpressOracle.PersistContract(neoSystem.GetSnapshot(), state, storagePairs);
+        }
+
+        public Task<bool> PersistContractAsync(ContractState state, (byte[] key, byte[] value)[] storagePairs) 
+            => MakeAsync(() => PersistContract(state, storagePairs));
+
     }
 }

src/neoxp/Node/OnlineNode.cs

@@ -328,5 +328,24 @@ public async Task<IReadOnlyList<ExpressStorage>> ListStoragesAsync(UInt160 scrip
 
             return Array.Empty<ExpressStorage>();
         }
+
+        public async Task<bool> PersistContractAsync(ContractState state, (byte[] key, byte[] value)[] storagePairs)
+        {
+            JObject o = new JObject();
+            o["state"] = state.ToJson();
+
+            JArray storage = new JArray();
+            foreach (var pair in storagePairs)
+            {
+                JObject kv = new JObject();
+                kv["key"] = Convert.ToBase64String(pair.key);
+                kv["value"] = Convert.ToBase64String(pair.value);
+                storage.Add(kv);
+            } 
+            o["storage"] = storage;
+
+            var response = await rpcClient.RpcSendAsync("expresspersistcontract", o).ConfigureAwait(false);
+            return response.AsBoolean();
+        }
     }
 }