feat: core deployment toolkit with tested RPC integration

README.md

@@ -78,6 +78,17 @@ Code analyzers and linting tools to help write secure and efficient contracts.
 
 Project templates for creating new NEO smart contracts with the proper structure and configurations.
 
+### Neo.SmartContract.Deploy
+
+A streamlined deployment toolkit that provides a simplified API for Neo smart contract deployment. Features include:
+
+- **Simple API**: Easy-to-use methods for deploying contracts from source code or artifacts
+- **Network Support**: Support for mainnet, testnet, and private network deployment
+- **WIF Key Integration**: Direct signing with WIF (Wallet Import Format) keys
+- **Contract Interaction**: Call and invoke contract methods after deployment
+- **Balance Checking**: Monitor GAS balances for deployment accounts
+- **Manifest Deployment**: Deploy multiple contracts from deployment manifests
+
 ## Getting Started
 
 ### Prerequisites
@@ -309,6 +320,113 @@ The repository includes various example contracts that demonstrate different fea
 
 Each example comes with corresponding unit tests that demonstrate how to properly test the contract functionality.
 
+## Contract Deployment
+
+This PR implements deployment from compiled artifacts (.nef + manifest) and basic RPC interactions (call, invoke, GAS balance, contract existence). Deploying from source projects (compilation) and multi-contract manifest deployment are not included.
+
+The `Neo.SmartContract.Deploy` package provides a streamlined way to deploy contracts to the NEO blockchain. It supports deployment from source code, compiled artifacts, and deployment manifests.
+
+### Installation
+
+```shell
+dotnet add package Neo.SmartContract.Deploy
+```
+
+### Basic Usage
+
+```csharp
+using Neo.SmartContract.Deploy;
+
+// Create deployment toolkit
+var deployment = new DeploymentToolkit()
+    .SetNetwork("testnet")
+    .SetWifKey("your-wif-key-here");
+
+// Deploy from source code
+var result = await deployment.DeployAsync("MyContract.cs");
+
+if (result.Success)
+{
+    Console.WriteLine($"Contract deployed: {result.ContractHash}");
+    Console.WriteLine($"Transaction: {result.TransactionHash}");
+}
+else
+{
+    Console.WriteLine($"Deployment failed: {result.ErrorMessage}");
+}
+```
+
+### Artifact Deployment
+
+```csharp
+// Deploy with initialization parameters
+var initParams = new object[] { "param1", 42, true };
+var result = await deployment.DeployAsync("MyContract.cs", initParams);
+
+// Deploy from compiled artifacts (.nef + manifest)
+var artifactsResult = await deployment.DeployArtifactsAsync(
+    "MyContract.nef",
+    "MyContract.manifest.json",
+    initParams,
+    waitForConfirmation: true);
+
+Console.WriteLine($"Tx: {artifactsResult.TransactionHash}");
+Console.WriteLine($"Expected Contract Hash: {artifactsResult.ContractHash}");
+
+Example app: See `examples/DeploymentArtifactsDemo` for a minimal console that deploys from NEF + manifest and performs read-only calls.
+
+// Deploy multiple contracts from manifest
+var manifestResult = await deployment.DeployFromManifestAsync("deployment-manifest.json");
+```
+
+### Network Configuration
+
+```csharp
+// Use predefined networks
+deployment.SetNetwork("mainnet");
+deployment.SetNetwork("testnet"); 
+deployment.SetNetwork("local");
+
+// Or use custom RPC URL
+deployment.SetNetwork("https://my-custom-rpc.com:10332");
+```
+
+### Contract Interaction
+
+```csharp
+// Call contract method (read-only)
+var balance = await deployment.CallAsync<int>("contract-hash", "balanceOf", "account-address");
+
+// Invoke contract method (state-changing)
+var txHash = await deployment.InvokeAsync("contract-hash", "transfer", fromAccount, toAccount, amount);
+
+// Check contract existence
+var exists = await deployment.ContractExistsAsync("contract-hash");
+
+// Get account balance
+var gasBalance = await deployment.GetGasBalanceAsync();
+```
+
+### Configuration File Support
+
+Create an `appsettings.json` file for configuration:
+
+```json
+{
+  "Network": {
+    "RpcUrl": "https://testnet1.neo.coz.io:443",
+    "Network": "testnet"
+  },
+  "Deployment": {
+    "GasLimit": 100000000,
+    "WaitForConfirmation": true
+  },
+  "Wallet": {
+    "Path": "wallet.json"
+  }
+}
+```
+
 ## Documentation
 
 For detailed documentation on NEO smart contract development with .NET:

examples/DeploymentArtifactsDemo/DeploymentArtifactsDemo.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <DisableExamplesPreBuild>true</DisableExamplesPreBuild>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- Remove references inherited from examples/Directory.Build.props that are only for contract projects -->
+    <ProjectReference Remove="..\..\src\Neo.Compiler.CSharp\Neo.Compiler.CSharp.csproj" />
+    <ProjectReference Remove="..\..\src\Neo.SmartContract.Analyzer\Neo.SmartContract.Analyzer.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Neo.SmartContract.Deploy\Neo.SmartContract.Deploy.csproj" />
+  </ItemGroup>
+
+</Project>

examples/DeploymentArtifactsDemo/Program.cs

@@ -0,0 +1,104 @@
+using Neo.SmartContract.Deploy;
+using System.Text.Json;
+
+static void PrintUsage()
+{
+    Console.WriteLine("Usage:");
+    Console.WriteLine("  dotnet run -- --network <mainnet|testnet|http(s)://rpc> --wif <WIF> --nef <path> --manifest <path> [--wait]");
+    Console.WriteLine("  dotnet run -- --network <...> --call --contract <hash|address> --method <name> [--args '[\"arg1\",123,true]']");
+    Console.WriteLine();
+    Console.WriteLine("Examples:");
+    Console.WriteLine("  dotnet run -- --network testnet --wif Kx... --nef My.nef --manifest My.manifest.json --wait");
+    Console.WriteLine("  dotnet run -- --network testnet --call --contract 0x... --method symbol");
+}
+
+string? GetArg(string key)
+{
+    for (int i = 0; i < args.Length - 1; i++)
+        if (string.Equals(args[i], key, StringComparison.OrdinalIgnoreCase))
+            return args[i + 1];
+    return null;
+}
+
+bool HasFlag(string key) => args.Any(a => string.Equals(a, key, StringComparison.OrdinalIgnoreCase));
+
+if (args.Length == 0 || HasFlag("--help") || HasFlag("-h"))
+{
+    PrintUsage();
+    return;
+}
+
+var network = GetArg("--network") ?? Environment.GetEnvironmentVariable("NEO_RPC_URL") ?? "testnet";
+var wif = GetArg("--wif") ?? Environment.GetEnvironmentVariable("NEO_WIF");
+var nef = GetArg("--nef");
+var manifest = GetArg("--manifest");
+var wait = HasFlag("--wait");
+
+var doCall = HasFlag("--call");
+var contract = GetArg("--contract");
+var method = GetArg("--method");
+var argsJson = GetArg("--args");
+
+var toolkit = new DeploymentToolkit().SetNetwork(network);
+
+try
+{
+    if (!doCall)
+    {
+        if (string.IsNullOrEmpty(wif) || string.IsNullOrEmpty(nef) || string.IsNullOrEmpty(manifest))
+        {
+            Console.Error.WriteLine("Missing required parameters for deployment.\n");
+            PrintUsage();
+            return;
+        }
+
+        toolkit.SetWifKey(wif);
+        var initParams = Array.Empty<object>();
+        var result = await toolkit.DeployArtifactsAsync(nef, manifest, initParams, waitForConfirmation: wait);
+        Console.WriteLine($"Transaction Hash: {result.TransactionHash}");
+        Console.WriteLine($"Expected Contract Hash: {result.ContractHash}");
+    }
+    else
+    {
+        if (string.IsNullOrEmpty(contract) || string.IsNullOrEmpty(method))
+        {
+            Console.Error.WriteLine("Missing required parameters for call.\n");
+            PrintUsage();
+            return;
+        }
+
+        object[] callArgs = Array.Empty<object>();
+        if (!string.IsNullOrEmpty(argsJson))
+        {
+            try
+            {
+                var doc = JsonDocument.Parse(argsJson);
+                if (doc.RootElement.ValueKind == JsonValueKind.Array)
+                {
+                    callArgs = doc.RootElement.EnumerateArray().Select(el => el.ValueKind switch
+                    {
+                        JsonValueKind.String => (object)el.GetString()!,
+                        JsonValueKind.Number => el.TryGetInt64(out var l) ? (object)l : el.GetDouble(),
+                        JsonValueKind.True => true,
+                        JsonValueKind.False => false,
+                        _ => el.ToString()
+                    }).ToArray();
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine($"Failed to parse --args JSON: {ex.Message}");
+                return;
+            }
+        }
+
+        var value = await toolkit.CallAsync<string>(contract, method, callArgs);
+        Console.WriteLine($"Result: {value}");
+    }
+}
+catch (Exception ex)
+{
+    Console.Error.WriteLine($"Error: {ex.Message}");
+    Environment.ExitCode = 1;
+}
+

examples/Directory.Build.props

@@ -27,7 +27,7 @@
                           OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>
     </ItemGroup>
 
-    <Target Name="ExecuteBeforeBuild" BeforeTargets="PreBuildEvent">
+    <Target Name="ExecuteBeforeBuild" BeforeTargets="PreBuildEvent" Condition="'$(DisableExamplesPreBuild)' != 'true'">
         <MSBuild Projects="..\..\src\Neo.Compiler.CSharp\Neo.Compiler.CSharp.csproj" Targets="Build" ContinueOnError="true"/>
         <Exec Command="dotnet ..\..\src\Neo.Compiler.CSharp\bin\Debug\net9.0\nccs.dll &quot;$(MSBuildProjectFile)&quot;" ContinueOnError="true"/>
     </Target>

neo-devpack-dotnet.sln

@@ -46,6 +46,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.SmartContract.Analyzer.
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Neo.Disassembler.CSharp", "src\Neo.Disassembler.CSharp\Neo.Disassembler.CSharp.csproj", "{FA988C67-43CF-4AE4-94FE-023AADFF88D6}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.SmartContract.Deploy", "src\Neo.SmartContract.Deploy\Neo.SmartContract.Deploy.csproj", "{B8A5D9F3-8C7E-4A1B-9D2F-3F8A9B5C7E1A}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.SmartContract.Deploy.UnitTests", "tests\Neo.SmartContract.Deploy.UnitTests\Neo.SmartContract.Deploy.UnitTests.csproj", "{A7B6C9D2-5E8F-4C3B-8A1D-2F9A8B5C7E4F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -128,6 +132,14 @@ Global
 		{FA988C67-43CF-4AE4-94FE-023AADFF88D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FA988C67-43CF-4AE4-94FE-023AADFF88D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FA988C67-43CF-4AE4-94FE-023AADFF88D6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B8A5D9F3-8C7E-4A1B-9D2F-3F8A9B5C7E1A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B8A5D9F3-8C7E-4A1B-9D2F-3F8A9B5C7E1A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B8A5D9F3-8C7E-4A1B-9D2F-3F8A9B5C7E1A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B8A5D9F3-8C7E-4A1B-9D2F-3F8A9B5C7E1A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A7B6C9D2-5E8F-4C3B-8A1D-2F9A8B5C7E4F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A7B6C9D2-5E8F-4C3B-8A1D-2F9A8B5C7E4F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A7B6C9D2-5E8F-4C3B-8A1D-2F9A8B5C7E4F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A7B6C9D2-5E8F-4C3B-8A1D-2F9A8B5C7E4F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -152,6 +164,8 @@ Global
 		{C2B7927F-AAA5-432A-8E76-B5080BD7EFB9} = {49D5873D-7B38-48A5-B853-85146F032091}
 		{F30E2375-012A-4A38-985B-31CB7DBA4D28} = {D5266066-0AFD-44D5-A83E-2F73668A63C8}
 		{FA988C67-43CF-4AE4-94FE-023AADFF88D6} = {79389FC0-C621-4CEA-AD2B-6074C32E7BCA}
+		{B8A5D9F3-8C7E-4A1B-9D2F-3F8A9B5C7E1A} = {79389FC0-C621-4CEA-AD2B-6074C32E7BCA}
+		{A7B6C9D2-5E8F-4C3B-8A1D-2F9A8B5C7E4F} = {D5266066-0AFD-44D5-A83E-2F73668A63C8}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {6DA935E1-C674-4364-B087-F1B511B79215}

src/Neo.Compiler.CSharp/ABI/AbiMethod.cs

@@ -28,8 +28,19 @@ public AbiMethod(IMethodSymbol symbol)
             : base(symbol, symbol.GetDisplayName(true), symbol.Parameters.Select(p => p.ToAbiParameter()).ToArray())
         {
             Symbol = symbol;
-            Safe = symbol.GetAttributes().Any(p => p.AttributeClass!.Name == nameof(scfx::Neo.SmartContract.Framework.Attributes.SafeAttribute));
+            Safe = GetSafeAttribute(symbol) != null;
+            if (Safe && symbol.MethodKind == MethodKind.PropertySet)
+                throw new CompilationException(symbol, DiagnosticId.SafeSetter, "Safe setters are not allowed.");
             ReturnType = symbol.ReturnType.GetContractParameterType();
         }
+
+        private static AttributeData? GetSafeAttribute(IMethodSymbol symbol)
+        {
+            AttributeData? attribute = symbol.GetAttributes().FirstOrDefault(p => p.AttributeClass!.Name == nameof(scfx::Neo.SmartContract.Framework.Attributes.SafeAttribute));
+            if (attribute != null) return attribute;
+            if (symbol.AssociatedSymbol is IPropertySymbol property)
+                return property.GetAttributes().FirstOrDefault(p => p.AttributeClass!.Name == nameof(scfx::Neo.SmartContract.Framework.Attributes.SafeAttribute));
+            return null;
+        }
     }
 }

src/Neo.Compiler.CSharp/Diagnostic/DiagnosticId.cs

@@ -39,5 +39,6 @@ static class DiagnosticId
         public const string CapturedStaticFieldNotFound = "NC3007";
         public const string InvalidType = "NC3008";
         public const string InvalidArgument = "NC3009";
+        public const string SafeSetter = "NC3010";
     }
 }