diff --git a/.editorconfig b/.editorconfig
index f24ccd45a8..c8247e5496 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -307,4 +307,4 @@ dotnet_diagnostic.IDE2006.severity = warning
[src/{VisualStudio}/**/*.{cs,vb}]
# CA1822: Make member static
# There is a risk of accidentally breaking an internal API that partners rely on though IVT.
-dotnet_code_quality.CA1822.api_surface = private
\ No newline at end of file
+dotnet_code_quality.CA1822.api_surface = private
diff --git a/.gitattributes b/.gitattributes
index 3bdf2f7093..95c6696127 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -4,6 +4,8 @@
* text eol=lf
*.cs eol=lf
*.csproj eol=lf
+*.props eol=lf
+*.json eol=lf
###############################################################################
# Set default behavior for command prompt diff.
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 5ac5e3dc65..6f7f9867c8 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -34,15 +34,25 @@ jobs:
- name: Test
if: matrix.os != 'ubuntu-latest'
run: |
+ dotnet sln neo.sln remove ./tests/Neo.Plugins.Storage.Tests/Neo.Plugins.Storage.Tests.csproj
dotnet test
- name: Test for coverall
if: matrix.os == 'ubuntu-latest'
run: |
+ sudo apt-get --assume-yes install libleveldb-dev librocksdb-dev
dotnet test ./tests/Neo.Cryptography.BLS12_381.Tests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/'
dotnet test ./tests/Neo.ConsoleService.Tests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json'
dotnet test ./tests/Neo.UnitTests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json'
dotnet test ./tests/Neo.VM.Tests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json'
- dotnet test ./tests/Neo.Json.UnitTests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json' /p:CoverletOutputFormat='lcov'
+ dotnet test ./tests/Neo.Json.UnitTests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json'
+
+ # Plugins
+ dotnet test ./tests/Neo.Cryptography.MPTTrie.Tests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json'
+ dotnet test ./tests/Neo.Network.RPC.Tests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json'
+ dotnet test ./tests/Neo.Plugins.OracleService.Tests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json'
+ dotnet test ./tests/Neo.Plugins.RpcServer.Tests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json'
+ dotnet test ./tests/Neo.Plugins.Storage.Tests /p:CollectCoverage=true /p:CoverletOutput='${{ github.workspace }}/TestResults/coverage/' /p:MergeWith='${{ github.workspace }}/TestResults/coverage/coverage.json' /p:CoverletOutputFormat='lcov'
+
- name: Coveralls
if: matrix.os == 'ubuntu-latest'
uses: coverallsapp/github-action@v2.2.3
diff --git a/src/README.md b/.neo/README.md
similarity index 100%
rename from src/README.md
rename to .neo/README.md
diff --git a/src/neo.png b/.neo/neo.png
similarity index 100%
rename from src/neo.png
rename to .neo/neo.png
diff --git a/neo.sln b/neo.sln
index b62de06a6e..46ff7c64e8 100644
--- a/neo.sln
+++ b/neo.sln
@@ -36,9 +36,49 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.Cryptography.BLS12_381"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.Cryptography.BLS12_381.Tests", "tests\Neo.Cryptography.BLS12_381.Tests\Neo.Cryptography.BLS12_381.Tests.csproj", "{387CCF6C-9A26-43F6-A639-0A82E91E10D8}"
EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Neo.IO", "src\Neo.IO\Neo.IO.csproj", "{4CDAC1AA-45C6-4157-8D8E-199050433048}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.IO", "src\Neo.IO\Neo.IO.csproj", "{4CDAC1AA-45C6-4157-8D8E-199050433048}"
EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Neo.Extensions", "src\Neo.Extensions\Neo.Extensions.csproj", "{9C5213D6-3833-4570-8AE2-47E9F9017A8F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.Extensions", "src\Neo.Extensions\Neo.Extensions.csproj", "{9C5213D6-3833-4570-8AE2-47E9F9017A8F}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "plugins", "plugins", "{C2DC830A-327A-42A7-807D-295216D30DBB}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.Cryptography.MPTTrie.Tests", "tests\Neo.Cryptography.MPTTrie.Tests\Neo.Cryptography.MPTTrie.Tests.csproj", "{FAF5D8AC-B6B3-4CD4-879D-0E5F6211480F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.Network.RPC.Tests", "tests\Neo.Network.RPC.Tests\Neo.Network.RPC.Tests.csproj", "{0E92F219-1225-4DD0-8C4A-98840985D59C}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.Plugins.OracleService.Tests", "tests\Neo.Plugins.OracleService.Tests\Neo.Plugins.OracleService.Tests.csproj", "{5D9764FB-827D-4DDE-84E3-3C05FD8ABC89}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.Plugins.RpcServer.Tests", "tests\Neo.Plugins.RpcServer.Tests\Neo.Plugins.RpcServer.Tests.csproj", "{2CBD2311-BA2E-4921-A000-FDDA59B74958}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.Plugins.Storage.Tests", "tests\Neo.Plugins.Storage.Tests\Neo.Plugins.Storage.Tests.csproj", "{EF01E062-DBBC-47AF-AF3B-9EDEB00CFF7C}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{7F257712-D033-47FF-B439-9D4320D06599}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ApplicationLogs", "src\Plugins\ApplicationLogs\ApplicationLogs.csproj", "{22E2CE64-080B-4138-885F-7FA74A9159FB}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DBFTPlugin", "src\Plugins\DBFTPlugin\DBFTPlugin.csproj", "{4C39E872-FC37-4BFD-AE4C-3E3F0546B726}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LevelDBStore", "src\Plugins\LevelDBStore\LevelDBStore.csproj", "{4C4D8180-9326-486C-AECF-8368BBD0766A}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MPTTrie", "src\Plugins\MPTTrie\MPTTrie.csproj", "{80DA3CE7-9770-4F00-9179-0DA91DABFDFA}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OracleService", "src\Plugins\OracleService\OracleService.csproj", "{DE0FB77E-3099-4C88-BB7D-BFAED75D813E}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RocksDBStore", "src\Plugins\RocksDBStore\RocksDBStore.csproj", "{3DE59148-59D6-4CD3-8086-0BC74E3D4E0B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RpcServer", "src\Plugins\RpcServer\RpcServer.csproj", "{A3941551-E72C-42D7-8C4D-5122CB60D73D}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SQLiteWallet", "src\Plugins\SQLiteWallet\SQLiteWallet.csproj", "{F53D5FF0-5D3D-4E8B-A44F-C4C5D9B563B1}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StatesDumper", "src\Plugins\StatesDumper\StatesDumper.csproj", "{90CCA7D4-C277-4112-A036-BBB90C3FE3BE}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StateService", "src\Plugins\StateService\StateService.csproj", "{88975A8D-4797-45A4-BC3E-15962A425A54}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StorageDumper", "src\Plugins\StorageDumper\StorageDumper.csproj", "{FF76D8A4-356B-461A-8471-BC1B83E57BBC}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TokensTracker", "src\Plugins\TokensTracker\TokensTracker.csproj", "{5E4947F3-05D3-4806-B0F3-30DAC71B5986}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RpcClient", "src\Plugins\RpcClient\RpcClient.csproj", "{185ADAFC-BFC6-413D-BC2E-97F9FB0A8AF0}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -110,6 +150,78 @@ Global
{9C5213D6-3833-4570-8AE2-47E9F9017A8F}.Debug|Any CPU.Build.0 = Debug|Any CPU
{9C5213D6-3833-4570-8AE2-47E9F9017A8F}.Release|Any CPU.ActiveCfg = Release|Any CPU
{9C5213D6-3833-4570-8AE2-47E9F9017A8F}.Release|Any CPU.Build.0 = Release|Any CPU
+ {FAF5D8AC-B6B3-4CD4-879D-0E5F6211480F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {FAF5D8AC-B6B3-4CD4-879D-0E5F6211480F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {FAF5D8AC-B6B3-4CD4-879D-0E5F6211480F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {FAF5D8AC-B6B3-4CD4-879D-0E5F6211480F}.Release|Any CPU.Build.0 = Release|Any CPU
+ {0E92F219-1225-4DD0-8C4A-98840985D59C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {0E92F219-1225-4DD0-8C4A-98840985D59C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {0E92F219-1225-4DD0-8C4A-98840985D59C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {0E92F219-1225-4DD0-8C4A-98840985D59C}.Release|Any CPU.Build.0 = Release|Any CPU
+ {5D9764FB-827D-4DDE-84E3-3C05FD8ABC89}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {5D9764FB-827D-4DDE-84E3-3C05FD8ABC89}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {5D9764FB-827D-4DDE-84E3-3C05FD8ABC89}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {5D9764FB-827D-4DDE-84E3-3C05FD8ABC89}.Release|Any CPU.Build.0 = Release|Any CPU
+ {2CBD2311-BA2E-4921-A000-FDDA59B74958}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {2CBD2311-BA2E-4921-A000-FDDA59B74958}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {2CBD2311-BA2E-4921-A000-FDDA59B74958}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {2CBD2311-BA2E-4921-A000-FDDA59B74958}.Release|Any CPU.Build.0 = Release|Any CPU
+ {EF01E062-DBBC-47AF-AF3B-9EDEB00CFF7C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {EF01E062-DBBC-47AF-AF3B-9EDEB00CFF7C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {EF01E062-DBBC-47AF-AF3B-9EDEB00CFF7C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {EF01E062-DBBC-47AF-AF3B-9EDEB00CFF7C}.Release|Any CPU.Build.0 = Release|Any CPU
+ {22E2CE64-080B-4138-885F-7FA74A9159FB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {22E2CE64-080B-4138-885F-7FA74A9159FB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {22E2CE64-080B-4138-885F-7FA74A9159FB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {22E2CE64-080B-4138-885F-7FA74A9159FB}.Release|Any CPU.Build.0 = Release|Any CPU
+ {4C39E872-FC37-4BFD-AE4C-3E3F0546B726}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {4C39E872-FC37-4BFD-AE4C-3E3F0546B726}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {4C39E872-FC37-4BFD-AE4C-3E3F0546B726}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {4C39E872-FC37-4BFD-AE4C-3E3F0546B726}.Release|Any CPU.Build.0 = Release|Any CPU
+ {4C4D8180-9326-486C-AECF-8368BBD0766A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {4C4D8180-9326-486C-AECF-8368BBD0766A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {4C4D8180-9326-486C-AECF-8368BBD0766A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {4C4D8180-9326-486C-AECF-8368BBD0766A}.Release|Any CPU.Build.0 = Release|Any CPU
+ {80DA3CE7-9770-4F00-9179-0DA91DABFDFA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {80DA3CE7-9770-4F00-9179-0DA91DABFDFA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {80DA3CE7-9770-4F00-9179-0DA91DABFDFA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {80DA3CE7-9770-4F00-9179-0DA91DABFDFA}.Release|Any CPU.Build.0 = Release|Any CPU
+ {DE0FB77E-3099-4C88-BB7D-BFAED75D813E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {DE0FB77E-3099-4C88-BB7D-BFAED75D813E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {DE0FB77E-3099-4C88-BB7D-BFAED75D813E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {DE0FB77E-3099-4C88-BB7D-BFAED75D813E}.Release|Any CPU.Build.0 = Release|Any CPU
+ {3DE59148-59D6-4CD3-8086-0BC74E3D4E0B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {3DE59148-59D6-4CD3-8086-0BC74E3D4E0B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {3DE59148-59D6-4CD3-8086-0BC74E3D4E0B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {3DE59148-59D6-4CD3-8086-0BC74E3D4E0B}.Release|Any CPU.Build.0 = Release|Any CPU
+ {A3941551-E72C-42D7-8C4D-5122CB60D73D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {A3941551-E72C-42D7-8C4D-5122CB60D73D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {A3941551-E72C-42D7-8C4D-5122CB60D73D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {A3941551-E72C-42D7-8C4D-5122CB60D73D}.Release|Any CPU.Build.0 = Release|Any CPU
+ {F53D5FF0-5D3D-4E8B-A44F-C4C5D9B563B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {F53D5FF0-5D3D-4E8B-A44F-C4C5D9B563B1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {F53D5FF0-5D3D-4E8B-A44F-C4C5D9B563B1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {F53D5FF0-5D3D-4E8B-A44F-C4C5D9B563B1}.Release|Any CPU.Build.0 = Release|Any CPU
+ {90CCA7D4-C277-4112-A036-BBB90C3FE3BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {90CCA7D4-C277-4112-A036-BBB90C3FE3BE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {90CCA7D4-C277-4112-A036-BBB90C3FE3BE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {90CCA7D4-C277-4112-A036-BBB90C3FE3BE}.Release|Any CPU.Build.0 = Release|Any CPU
+ {88975A8D-4797-45A4-BC3E-15962A425A54}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {88975A8D-4797-45A4-BC3E-15962A425A54}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {88975A8D-4797-45A4-BC3E-15962A425A54}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {88975A8D-4797-45A4-BC3E-15962A425A54}.Release|Any CPU.Build.0 = Release|Any CPU
+ {FF76D8A4-356B-461A-8471-BC1B83E57BBC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {FF76D8A4-356B-461A-8471-BC1B83E57BBC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {FF76D8A4-356B-461A-8471-BC1B83E57BBC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {FF76D8A4-356B-461A-8471-BC1B83E57BBC}.Release|Any CPU.Build.0 = Release|Any CPU
+ {5E4947F3-05D3-4806-B0F3-30DAC71B5986}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {5E4947F3-05D3-4806-B0F3-30DAC71B5986}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {5E4947F3-05D3-4806-B0F3-30DAC71B5986}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {5E4947F3-05D3-4806-B0F3-30DAC71B5986}.Release|Any CPU.Build.0 = Release|Any CPU
+ {185ADAFC-BFC6-413D-BC2E-97F9FB0A8AF0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {185ADAFC-BFC6-413D-BC2E-97F9FB0A8AF0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {185ADAFC-BFC6-413D-BC2E-97F9FB0A8AF0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {185ADAFC-BFC6-413D-BC2E-97F9FB0A8AF0}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
@@ -131,6 +243,25 @@ Global
{387CCF6C-9A26-43F6-A639-0A82E91E10D8} = {EDE05FA8-8E73-4924-BC63-DD117127EEE1}
{4CDAC1AA-45C6-4157-8D8E-199050433048} = {B5339DF7-5D1D-43BA-B332-74B825E1770E}
{9C5213D6-3833-4570-8AE2-47E9F9017A8F} = {B5339DF7-5D1D-43BA-B332-74B825E1770E}
+ {FAF5D8AC-B6B3-4CD4-879D-0E5F6211480F} = {7F257712-D033-47FF-B439-9D4320D06599}
+ {0E92F219-1225-4DD0-8C4A-98840985D59C} = {7F257712-D033-47FF-B439-9D4320D06599}
+ {5D9764FB-827D-4DDE-84E3-3C05FD8ABC89} = {7F257712-D033-47FF-B439-9D4320D06599}
+ {2CBD2311-BA2E-4921-A000-FDDA59B74958} = {7F257712-D033-47FF-B439-9D4320D06599}
+ {EF01E062-DBBC-47AF-AF3B-9EDEB00CFF7C} = {7F257712-D033-47FF-B439-9D4320D06599}
+ {7F257712-D033-47FF-B439-9D4320D06599} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {22E2CE64-080B-4138-885F-7FA74A9159FB} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {4C39E872-FC37-4BFD-AE4C-3E3F0546B726} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {4C4D8180-9326-486C-AECF-8368BBD0766A} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {80DA3CE7-9770-4F00-9179-0DA91DABFDFA} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {DE0FB77E-3099-4C88-BB7D-BFAED75D813E} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {3DE59148-59D6-4CD3-8086-0BC74E3D4E0B} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {A3941551-E72C-42D7-8C4D-5122CB60D73D} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {F53D5FF0-5D3D-4E8B-A44F-C4C5D9B563B1} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {90CCA7D4-C277-4112-A036-BBB90C3FE3BE} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {88975A8D-4797-45A4-BC3E-15962A425A54} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {FF76D8A4-356B-461A-8471-BC1B83E57BBC} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {5E4947F3-05D3-4806-B0F3-30DAC71B5986} = {C2DC830A-327A-42A7-807D-295216D30DBB}
+ {185ADAFC-BFC6-413D-BC2E-97F9FB0A8AF0} = {C2DC830A-327A-42A7-807D-295216D30DBB}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {BCBA19D9-F868-4C6D-8061-A2B91E06E3EC}
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index 816760b50b..d3de66b478 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -19,8 +19,8 @@
-
-
+
+
diff --git a/src/Plugins/ApplicationLogs/ApplicationLogs.csproj b/src/Plugins/ApplicationLogs/ApplicationLogs.csproj
new file mode 100644
index 0000000000..2079abfcff
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/ApplicationLogs.csproj
@@ -0,0 +1,16 @@
+
+
+ net8.0
+ Neo.Plugins.ApplicationLogs
+ Neo.Plugins
+ enable
+
+
+
+
+
+ false
+ runtime
+
+
+
\ No newline at end of file
diff --git a/src/Plugins/ApplicationLogs/LogReader.cs b/src/Plugins/ApplicationLogs/LogReader.cs
new file mode 100644
index 0000000000..56163ef4f1
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/LogReader.cs
@@ -0,0 +1,457 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// LogReader.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using ApplicationLogs.Store;
+using ApplicationLogs.Store.Models;
+using Neo.ConsoleService;
+using Neo.IO;
+using Neo.Json;
+using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using Neo.VM;
+using System.Numerics;
+using static System.IO.Path;
+
+namespace Neo.Plugins
+{
+ public class LogReader : Plugin
+ {
+ #region Globals
+
+ private NeoStore _neostore;
+ private NeoSystem _neosystem;
+ private readonly List _logEvents;
+
+ #endregion
+
+ public override string Name => "ApplicationLogs";
+ public override string Description => "Synchronizes smart contract VM executions and notificatons (NotifyLog) on blockchain.";
+
+ #region Ctor
+
+ public LogReader()
+ {
+ _logEvents = new();
+ Blockchain.Committing += OnCommitting;
+ Blockchain.Committed += OnCommitted;
+ }
+
+ #endregion
+
+ #region Override Methods
+
+ public override void Dispose()
+ {
+ Blockchain.Committing -= OnCommitting;
+ Blockchain.Committed -= OnCommitted;
+ if (Settings.Default.Debug)
+ ApplicationEngine.Log -= OnApplicationEngineLog;
+ GC.SuppressFinalize(this);
+ }
+
+ protected override void Configure()
+ {
+ Settings.Load(GetConfiguration());
+ }
+
+ protected override void OnSystemLoaded(NeoSystem system)
+ {
+ if (system.Settings.Network != Settings.Default.Network)
+ return;
+ string path = string.Format(Settings.Default.Path, Settings.Default.Network.ToString("X8"));
+ var store = system.LoadStore(GetFullPath(path));
+ _neostore = new NeoStore(store);
+ _neosystem = system;
+ RpcServerPlugin.RegisterMethods(this, Settings.Default.Network);
+
+ if (Settings.Default.Debug)
+ ApplicationEngine.Log += OnApplicationEngineLog;
+ }
+
+ #endregion
+
+ #region JSON RPC Methods
+
+ [RpcMethod]
+ public JToken GetApplicationLog(JArray _params)
+ {
+ if (_params == null || _params.Count == 0)
+ throw new RpcException(RpcError.InvalidParams);
+ if (UInt256.TryParse(_params[0].AsString(), out var hash))
+ {
+ var raw = BlockToJObject(hash);
+ if (raw == null)
+ raw = TransactionToJObject(hash);
+ if (raw == null)
+ throw new RpcException(RpcError.InvalidParams.WithData("Unknown transaction/blockhash"));
+
+ if (_params.Count >= 2 && Enum.TryParse(_params[1].AsString(), true, out TriggerType triggerType))
+ {
+ var executions = raw["executions"] as JArray;
+ for (int i = 0; i < executions.Count;)
+ {
+ if (executions[i]["trigger"].AsString().Equals(triggerType.ToString(), StringComparison.OrdinalIgnoreCase) == false)
+ executions.RemoveAt(i);
+ else
+ i++;
+ }
+ }
+
+ return raw ?? JToken.Null;
+ }
+ else
+ throw new RpcException(RpcError.InvalidParams);
+ }
+
+ #endregion
+
+ #region Console Commands
+
+ [ConsoleCommand("log block", Category = "ApplicationLog Commands")]
+ private void OnGetBlockCommand(string blockHashOrIndex, string eventName = null)
+ {
+ UInt256 blockhash;
+ if (uint.TryParse(blockHashOrIndex, out var blockIndex))
+ {
+ blockhash = NativeContract.Ledger.GetBlockHash(_neosystem.StoreView, blockIndex);
+ }
+ else if (UInt256.TryParse(blockHashOrIndex, out blockhash) == false)
+ {
+ ConsoleHelper.Error("Invalid block hash or index.");
+ return;
+ }
+
+ var blockOnPersist = string.IsNullOrEmpty(eventName) ?
+ _neostore.GetBlockLog(blockhash, TriggerType.OnPersist) :
+ _neostore.GetBlockLog(blockhash, TriggerType.OnPersist, eventName);
+ var blockPostPersist = string.IsNullOrEmpty(eventName) ?
+ _neostore.GetBlockLog(blockhash, TriggerType.PostPersist) :
+ _neostore.GetBlockLog(blockhash, TriggerType.PostPersist, eventName);
+
+ if (blockOnPersist == null && blockOnPersist == null)
+ ConsoleHelper.Error($"No logs.");
+ if (blockOnPersist != null)
+ PrintExecutionToConsole(blockOnPersist);
+ if (blockPostPersist != null)
+ {
+ ConsoleHelper.Info("--------------------------------");
+ PrintExecutionToConsole(blockPostPersist);
+ }
+ }
+
+ [ConsoleCommand("log tx", Category = "ApplicationLog Commands")]
+ private void OnGetTransactionCommand(UInt256 txhash, string eventName = null)
+ {
+ var txApplication = string.IsNullOrEmpty(eventName) ?
+ _neostore.GetTransactionLog(txhash) :
+ _neostore.GetTransactionLog(txhash, eventName);
+
+ if (txApplication == null)
+ ConsoleHelper.Error($"No logs.");
+ else
+ PrintExecutionToConsole(txApplication);
+ }
+
+ [ConsoleCommand("log contract", Category = "ApplicationLog Commands")]
+ private void OnGetContractCommand(UInt160 scripthash, uint page = 1, uint pageSize = 1, string eventName = null)
+ {
+ if (page == 0)
+ {
+ ConsoleHelper.Error("Page is invalid. Pick a number 1 and above.");
+ return;
+ }
+
+ if (pageSize == 0)
+ {
+ ConsoleHelper.Error("PageSize is invalid. Pick a number between 1 and 10.");
+ return;
+ }
+
+ var txContract = string.IsNullOrEmpty(eventName) ?
+ _neostore.GetContractLog(scripthash, TriggerType.Application, page, pageSize) :
+ _neostore.GetContractLog(scripthash, TriggerType.Application, eventName, page, pageSize);
+
+ if (txContract.Count == 0)
+ ConsoleHelper.Error($"No logs.");
+ else
+ PrintEventModelToConsole(txContract);
+ }
+
+
+ #endregion
+
+ #region Blockchain Events
+
+ private void OnCommitting(NeoSystem system, Block block, DataCache snapshot, IReadOnlyList applicationExecutedList)
+ {
+ if (system.Settings.Network != Settings.Default.Network)
+ return;
+
+ if (_neostore is null)
+ return;
+ _neostore.StartBlockLogBatch();
+ _neostore.PutBlockLog(block, applicationExecutedList);
+ if (Settings.Default.Debug)
+ {
+ foreach (var appEng in applicationExecutedList.Where(w => w.Transaction != null))
+ {
+ var logs = _logEvents.Where(w => w.ScriptContainer.Hash == appEng.Transaction.Hash).ToList();
+ if (logs.Any())
+ _neostore.PutTransactionEngineLogState(appEng.Transaction.Hash, logs);
+ }
+ _logEvents.Clear();
+ }
+ }
+
+ private void OnCommitted(NeoSystem system, Block block)
+ {
+ if (system.Settings.Network != Settings.Default.Network)
+ return;
+ if (_neostore is null)
+ return;
+ _neostore.CommitBlockLog();
+ }
+
+ private void OnApplicationEngineLog(object sender, LogEventArgs e)
+ {
+ if (Settings.Default.Debug == false)
+ return;
+
+ if (_neosystem.Settings.Network != Settings.Default.Network)
+ return;
+
+ if (e.ScriptContainer == null)
+ return;
+
+ _logEvents.Add(e);
+ }
+
+ #endregion
+
+ #region Private Methods
+
+ private void PrintExecutionToConsole(BlockchainExecutionModel model)
+ {
+ ConsoleHelper.Info("Trigger: ", $"{model.Trigger}");
+ ConsoleHelper.Info("VM State: ", $"{model.VmState}");
+ if (string.IsNullOrEmpty(model.Exception) == false)
+ ConsoleHelper.Error($"Exception: {model.Exception}");
+ else
+ ConsoleHelper.Info("Exception: ", "null");
+ ConsoleHelper.Info("Gas Consumed: ", $"{new BigDecimal((BigInteger)model.GasConsumed, NativeContract.GAS.Decimals)}");
+ if (model.Stack.Length == 0)
+ ConsoleHelper.Info("Stack: ", "[]");
+ else
+ {
+ ConsoleHelper.Info("Stack: ");
+ for (int i = 0; i < model.Stack.Length; i++)
+ ConsoleHelper.Info($" {i}: ", $"{model.Stack[i].ToJson()}");
+ }
+ if (model.Notifications.Length == 0)
+ ConsoleHelper.Info("Notifications: ", "[]");
+ else
+ {
+ ConsoleHelper.Info("Notifications:");
+ foreach (var notifyItem in model.Notifications)
+ {
+ ConsoleHelper.Info();
+ ConsoleHelper.Info(" ScriptHash: ", $"{notifyItem.ScriptHash}");
+ ConsoleHelper.Info(" Event Name: ", $"{notifyItem.EventName}");
+ ConsoleHelper.Info(" State Parameters:");
+ for (int i = 0; i < notifyItem.State.Length; i++)
+ ConsoleHelper.Info($" {GetMethodParameterName(notifyItem.ScriptHash, notifyItem.EventName, i)}: ", $"{notifyItem.State[i].ToJson()}");
+ }
+ }
+ if (Settings.Default.Debug)
+ {
+ if (model.Logs.Length == 0)
+ ConsoleHelper.Info("Logs: ", "[]");
+ else
+ {
+ ConsoleHelper.Info("Logs:");
+ foreach (var logItem in model.Logs)
+ {
+ ConsoleHelper.Info();
+ ConsoleHelper.Info(" ScriptHash: ", $"{logItem.ScriptHash}");
+ ConsoleHelper.Info(" Message: ", $"{logItem.Message}");
+ }
+ }
+ }
+ }
+
+ private void PrintEventModelToConsole(IReadOnlyCollection<(BlockchainEventModel NotifyLog, UInt256 TxHash)> models)
+ {
+ foreach (var (notifyItem, txhash) in models)
+ {
+ ConsoleHelper.Info("Transaction Hash: ", $"{txhash}");
+ ConsoleHelper.Info();
+ ConsoleHelper.Info(" Event Name: ", $"{notifyItem.EventName}");
+ ConsoleHelper.Info(" State Parameters:");
+ for (int i = 0; i < notifyItem.State.Length; i++)
+ ConsoleHelper.Info($" {GetMethodParameterName(notifyItem.ScriptHash, notifyItem.EventName, i)}: ", $"{notifyItem.State[i].ToJson()}");
+ ConsoleHelper.Info("--------------------------------");
+ }
+ }
+
+ private string GetMethodParameterName(UInt160 scriptHash, string methodName, int parameterIndex)
+ {
+ var contract = NativeContract.ContractManagement.GetContract(_neosystem.StoreView, scriptHash);
+ if (contract == null)
+ return $"{parameterIndex}";
+ var contractEvent = contract.Manifest.Abi.Events.SingleOrDefault(s => s.Name == methodName);
+ return contractEvent.Parameters[parameterIndex].Name;
+ }
+
+ private JObject EventModelToJObject(BlockchainEventModel model)
+ {
+ var root = new JObject();
+ root["contract"] = model.ScriptHash.ToString();
+ root["eventname"] = model.EventName;
+ root["state"] = model.State.Select(s => s.ToJson()).ToArray();
+ return root;
+ }
+
+ private JObject TransactionToJObject(UInt256 txHash)
+ {
+ var appLog = _neostore.GetTransactionLog(txHash);
+ if (appLog == null)
+ return null;
+
+ var raw = new JObject();
+ raw["txid"] = txHash.ToString();
+
+ var trigger = new JObject();
+ trigger["trigger"] = appLog.Trigger;
+ trigger["vmstate"] = appLog.VmState;
+ trigger["exception"] = string.IsNullOrEmpty(appLog.Exception) ? null : appLog.Exception;
+ trigger["gasconsumed"] = appLog.GasConsumed.ToString();
+
+ try
+ {
+ trigger["stack"] = appLog.Stack.Select(s => s.ToJson(Settings.Default.MaxStackSize)).ToArray();
+ }
+ catch (Exception ex)
+ {
+ trigger["exception"] = ex.Message;
+ }
+
+ trigger["notifications"] = appLog.Notifications.Select(s =>
+ {
+ var notification = new JObject();
+ notification["contract"] = s.ScriptHash.ToString();
+ notification["eventname"] = s.EventName;
+
+ try
+ {
+ var state = new JObject();
+ state["type"] = "Array";
+ state["value"] = s.State.Select(ss => ss.ToJson()).ToArray();
+
+ notification["state"] = state;
+ }
+ catch (InvalidOperationException)
+ {
+ notification["state"] = "error: recursive reference";
+ }
+
+ return notification;
+ }).ToArray();
+
+ if (Settings.Default.Debug)
+ {
+ trigger["logs"] = appLog.Logs.Select(s =>
+ {
+ var log = new JObject();
+ log["contract"] = s.ScriptHash.ToString();
+ log["message"] = s.Message;
+ return log;
+ }).ToArray();
+ }
+
+ raw["executions"] = new[] { trigger };
+ return raw;
+ }
+
+ private JObject BlockToJObject(UInt256 blockHash)
+ {
+ var blockOnPersist = _neostore.GetBlockLog(blockHash, TriggerType.OnPersist);
+ var blockPostPersist = _neostore.GetBlockLog(blockHash, TriggerType.PostPersist);
+
+ if (blockOnPersist == null && blockPostPersist == null)
+ return null;
+
+ var blockJson = new JObject();
+ blockJson["blockhash"] = blockHash.ToString();
+ var triggerList = new List();
+
+ if (blockOnPersist != null)
+ triggerList.Add(BlockItemToJObject(blockOnPersist));
+ if (blockPostPersist != null)
+ triggerList.Add(BlockItemToJObject(blockPostPersist));
+
+ blockJson["executions"] = triggerList.ToArray();
+ return blockJson;
+ }
+
+ private JObject BlockItemToJObject(BlockchainExecutionModel blockExecutionModel)
+ {
+ JObject trigger = new();
+ trigger["trigger"] = blockExecutionModel.Trigger;
+ trigger["vmstate"] = blockExecutionModel.VmState;
+ trigger["gasconsumed"] = blockExecutionModel.GasConsumed.ToString();
+ try
+ {
+ trigger["stack"] = blockExecutionModel.Stack.Select(q => q.ToJson(Settings.Default.MaxStackSize)).ToArray();
+ }
+ catch (Exception ex)
+ {
+ trigger["exception"] = ex.Message;
+ }
+ trigger["notifications"] = blockExecutionModel.Notifications.Select(s =>
+ {
+ JObject notification = new();
+ notification["contract"] = s.ScriptHash.ToString();
+ notification["eventname"] = s.EventName;
+ try
+ {
+ var state = new JObject();
+ state["type"] = "Array";
+ state["value"] = s.State.Select(ss => ss.ToJson()).ToArray();
+
+ notification["state"] = state;
+ }
+ catch (InvalidOperationException)
+ {
+ notification["state"] = "error: recursive reference";
+ }
+ return notification;
+ }).ToArray();
+
+ if (Settings.Default.Debug)
+ {
+ trigger["logs"] = blockExecutionModel.Logs.Select(s =>
+ {
+ var log = new JObject();
+ log["contract"] = s.ScriptHash.ToString();
+ log["message"] = s.Message;
+ return log;
+ }).ToArray();
+ }
+
+ return trigger;
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Settings.cs b/src/Plugins/ApplicationLogs/Settings.cs
new file mode 100644
index 0000000000..1e425f664b
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Settings.cs
@@ -0,0 +1,39 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Settings.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Microsoft.Extensions.Configuration;
+
+namespace Neo.Plugins
+{
+ internal class Settings
+ {
+ public string Path { get; }
+ public uint Network { get; }
+ public int MaxStackSize { get; }
+
+ public bool Debug { get; }
+
+ public static Settings Default { get; private set; }
+
+ private Settings(IConfigurationSection section)
+ {
+ Path = section.GetValue("Path", "ApplicationLogs_{0}");
+ Network = section.GetValue("Network", 5195086u);
+ MaxStackSize = section.GetValue("MaxStackSize", (int)ushort.MaxValue);
+ Debug = section.GetValue("Debug", false);
+ }
+
+ public static void Load(IConfigurationSection section)
+ {
+ Default = new Settings(section);
+ }
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/LogStorageStore.cs b/src/Plugins/ApplicationLogs/Store/LogStorageStore.cs
new file mode 100644
index 0000000000..aa0357ffb2
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/LogStorageStore.cs
@@ -0,0 +1,415 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// LogStorageStore.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using ApplicationLogs.Store.States;
+using Neo;
+using Neo.IO;
+using Neo.Persistence;
+using Neo.Plugins;
+using Neo.Plugins.Store.States;
+using Neo.SmartContract;
+using Neo.VM;
+using Neo.VM.Types;
+
+namespace ApplicationLogs.Store
+{
+ public sealed class LogStorageStore : IDisposable
+ {
+ #region Prefixes
+
+ private static readonly int Prefix_Size = sizeof(int) + sizeof(byte);
+ private static readonly int Prefix_Block_Trigger_Size = Prefix_Size + UInt256.Length;
+ private static readonly int Prefix_Execution_Block_Trigger_Size = Prefix_Size + UInt256.Length;
+
+ private static readonly int Prefix_Id = 0x414c4f47; // Magic Code: (ALOG);
+ private static readonly byte Prefix_Engine = 0x18; // Engine_GUID -> ScriptHash, Message
+ private static readonly byte Prefix_Engine_Transaction = 0x19; // TxHash -> Engine_GUID_List
+ private static readonly byte Prefix_Block = 0x20; // BlockHash, Trigger -> NotifyLog_GUID_List
+ private static readonly byte Prefix_Notify = 0x21; // NotifyLog_GUID -> ScriptHash, EventName, StackItem_GUID_List
+ private static readonly byte Prefix_Contract = 0x22; // ScriptHash, TimeStamp, EventIterIndex -> txHash, Trigger, NotifyLog_GUID
+ private static readonly byte Prefix_Execution = 0x23; // Execution_GUID -> Data, StackItem_GUID_List
+ private static readonly byte Prefix_Execution_Block = 0x24; // BlockHash, Trigger -> Execution_GUID
+ private static readonly byte Prefix_Execution_Transaction = 0x25; // TxHash -> Execution_GUID
+ private static readonly byte Prefix_Transaction = 0x26; // TxHash -> NotifyLog_GUID_List
+ private static readonly byte Prefix_StackItem = 0xed; // StackItem_GUID -> Data
+
+ #endregion
+
+ #region Global Variables
+
+ private readonly ISnapshot _snapshot;
+
+ #endregion
+
+ #region Ctor
+
+ public LogStorageStore(ISnapshot snapshot)
+ {
+ ArgumentNullException.ThrowIfNull(snapshot, nameof(snapshot));
+ _snapshot = snapshot;
+ }
+
+ #endregion
+
+ #region IDisposable
+
+ public void Dispose()
+ {
+ GC.SuppressFinalize(this);
+ }
+
+ #endregion
+
+ #region Put
+
+ public Guid PutEngineState(EngineLogState state)
+ {
+ var id = Guid.NewGuid();
+ var key = new KeyBuilder(Prefix_Id, Prefix_Engine)
+ .Add(id.ToByteArray())
+ .ToArray();
+ _snapshot.Put(key, state.ToArray());
+ return id;
+ }
+
+ public void PutTransactionEngineState(UInt256 hash, TransactionEngineLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Engine_Transaction)
+ .Add(hash)
+ .ToArray();
+ _snapshot.Put(key, state.ToArray());
+ }
+
+ public void PutBlockState(UInt256 hash, TriggerType trigger, BlockLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Block)
+ .Add(hash)
+ .Add((byte)trigger)
+ .ToArray();
+ _snapshot.Put(key, state.ToArray());
+ }
+
+ public Guid PutNotifyState(NotifyLogState state)
+ {
+ var id = Guid.NewGuid();
+ var key = new KeyBuilder(Prefix_Id, Prefix_Notify)
+ .Add(id.ToByteArray())
+ .ToArray();
+ _snapshot.Put(key, state.ToArray());
+ return id;
+ }
+
+ public void PutContractState(UInt160 scriptHash, ulong timestamp, uint iterIndex, ContractLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Contract)
+ .Add(scriptHash)
+ .AddBigEndian(timestamp)
+ .AddBigEndian(iterIndex)
+ .ToArray();
+ _snapshot.Put(key, state.ToArray());
+ }
+
+ public Guid PutExecutionState(ExecutionLogState state)
+ {
+ var id = Guid.NewGuid();
+ var key = new KeyBuilder(Prefix_Id, Prefix_Execution)
+ .Add(id.ToByteArray())
+ .ToArray();
+ _snapshot.Put(key, state.ToArray());
+ return id;
+ }
+
+ public void PutExecutionBlockState(UInt256 blockHash, TriggerType trigger, Guid executionStateId)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Execution_Block)
+ .Add(blockHash)
+ .Add((byte)trigger)
+ .ToArray();
+ _snapshot.Put(key, executionStateId.ToByteArray());
+ }
+
+ public void PutExecutionTransactionState(UInt256 txHash, Guid executionStateId)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Execution_Transaction)
+ .Add(txHash)
+ .ToArray();
+ _snapshot.Put(key, executionStateId.ToByteArray());
+ }
+
+ public void PutTransactionState(UInt256 hash, TransactionLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Transaction)
+ .Add(hash)
+ .ToArray();
+ _snapshot.Put(key, state.ToArray());
+ }
+
+ public Guid PutStackItemState(StackItem stackItem)
+ {
+ var id = Guid.NewGuid();
+ var key = new KeyBuilder(Prefix_Id, Prefix_StackItem)
+ .Add(id.ToByteArray())
+ .ToArray();
+ try
+ {
+ _snapshot.Put(key, BinarySerializer.Serialize(stackItem, ExecutionEngineLimits.Default with { MaxItemSize = (uint)Settings.Default.MaxStackSize }));
+ }
+ catch (NotSupportedException)
+ {
+ _snapshot.Put(key, BinarySerializer.Serialize(StackItem.Null, ExecutionEngineLimits.Default with { MaxItemSize = (uint)Settings.Default.MaxStackSize }));
+ }
+ return id;
+ }
+
+ #endregion
+
+ #region Find
+
+ public IEnumerable<(BlockLogState State, TriggerType Trigger)> FindBlockState(UInt256 hash)
+ {
+ var prefixKey = new KeyBuilder(Prefix_Id, Prefix_Block)
+ .Add(hash)
+ .ToArray();
+ foreach (var (key, value) in _snapshot.Seek(prefixKey, SeekDirection.Forward))
+ {
+ if (key.AsSpan().StartsWith(prefixKey))
+ yield return (value.AsSerializable(), (TriggerType)key.AsSpan(Prefix_Block_Trigger_Size)[0]);
+ else
+ yield break;
+ }
+ }
+
+ public IEnumerable FindContractState(UInt160 scriptHash, uint page, uint pageSize)
+ {
+ var prefix = new KeyBuilder(Prefix_Id, Prefix_Contract)
+ .Add(scriptHash)
+ .ToArray();
+ var prefixKey = new KeyBuilder(Prefix_Id, Prefix_Contract)
+ .Add(scriptHash)
+ .AddBigEndian(ulong.MaxValue) // Get newest to oldest (timestamp)
+ .ToArray();
+ uint index = 1;
+ foreach (var (key, value) in _snapshot.Seek(prefixKey, SeekDirection.Backward)) // Get newest to oldest
+ {
+ if (key.AsSpan().StartsWith(prefix))
+ {
+ if (index >= page && index < (pageSize + page))
+ yield return value.AsSerializable();
+ index++;
+ }
+ else
+ yield break;
+ }
+ }
+
+ public IEnumerable FindContractState(UInt160 scriptHash, TriggerType trigger, uint page, uint pageSize)
+ {
+ var prefix = new KeyBuilder(Prefix_Id, Prefix_Contract)
+ .Add(scriptHash)
+ .ToArray();
+ var prefixKey = new KeyBuilder(Prefix_Id, Prefix_Contract)
+ .Add(scriptHash)
+ .AddBigEndian(ulong.MaxValue) // Get newest to oldest (timestamp)
+ .ToArray();
+ uint index = 1;
+ foreach (var (key, value) in _snapshot.Seek(prefixKey, SeekDirection.Backward)) // Get newest to oldest
+ {
+ if (key.AsSpan().StartsWith(prefix))
+ {
+ var state = value.AsSerializable();
+ if (state.Trigger == trigger)
+ {
+ if (index >= page && index < (pageSize + page))
+ yield return state;
+ index++;
+ }
+ }
+ else
+ yield break;
+ }
+ }
+
+ public IEnumerable FindContractState(UInt160 scriptHash, TriggerType trigger, string eventName, uint page, uint pageSize)
+ {
+ var prefix = new KeyBuilder(Prefix_Id, Prefix_Contract)
+ .Add(scriptHash)
+ .ToArray();
+ var prefixKey = new KeyBuilder(Prefix_Id, Prefix_Contract)
+ .Add(scriptHash)
+ .AddBigEndian(ulong.MaxValue) // Get newest to oldest (timestamp)
+ .ToArray();
+ uint index = 1;
+ foreach (var (key, value) in _snapshot.Seek(prefixKey, SeekDirection.Backward)) // Get newest to oldest
+ {
+ if (key.AsSpan().StartsWith(prefix))
+ {
+ var state = value.AsSerializable();
+ if (state.Trigger == trigger && state.EventName.Equals(eventName, StringComparison.OrdinalIgnoreCase))
+ {
+ if (index >= page && index < (pageSize + page))
+ yield return state;
+ index++;
+ }
+ }
+ else
+ yield break;
+ }
+ }
+
+ public IEnumerable<(Guid ExecutionStateId, TriggerType Trigger)> FindExecutionBlockState(UInt256 hash)
+ {
+ var prefixKey = new KeyBuilder(Prefix_Id, Prefix_Execution_Block)
+ .Add(hash)
+ .ToArray();
+ foreach (var (key, value) in _snapshot.Seek(prefixKey, SeekDirection.Forward))
+ {
+ if (key.AsSpan().StartsWith(prefixKey))
+ yield return (new Guid(value), (TriggerType)key.AsSpan(Prefix_Execution_Block_Trigger_Size)[0]);
+ else
+ yield break;
+ }
+ }
+
+ #endregion
+
+ #region TryGet
+
+ public bool TryGetEngineState(Guid engineStateId, out EngineLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Engine)
+ .Add(engineStateId.ToByteArray())
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ state = data?.AsSerializable()!;
+ return data != null && data.Length > 0;
+ }
+
+ public bool TryGetTransactionEngineState(UInt256 hash, out TransactionEngineLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Engine_Transaction)
+ .Add(hash)
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ state = data?.AsSerializable()!;
+ return data != null && data.Length > 0;
+ }
+
+ public bool TryGetBlockState(UInt256 hash, TriggerType trigger, out BlockLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Block)
+ .Add(hash)
+ .Add((byte)trigger)
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ state = data?.AsSerializable()!;
+ return data != null && data.Length > 0;
+ }
+
+ public bool TryGetNotifyState(Guid notifyStateId, out NotifyLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Notify)
+ .Add(notifyStateId.ToByteArray())
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ state = data?.AsSerializable()!;
+ return data != null && data.Length > 0;
+ }
+
+ public bool TryGetContractState(UInt160 scriptHash, ulong timestamp, uint iterIndex, out ContractLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Contract)
+ .Add(scriptHash)
+ .AddBigEndian(timestamp)
+ .AddBigEndian(iterIndex)
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ state = data?.AsSerializable()!;
+ return data != null && data.Length > 0;
+ }
+
+ public bool TryGetExecutionState(Guid executionStateId, out ExecutionLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Execution)
+ .Add(executionStateId.ToByteArray())
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ state = data?.AsSerializable()!;
+ return data != null && data.Length > 0;
+ }
+
+ public bool TryGetExecutionBlockState(UInt256 blockHash, TriggerType trigger, out Guid executionStateId)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Execution_Block)
+ .Add(blockHash)
+ .Add((byte)trigger)
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ if (data == null)
+ {
+ executionStateId = Guid.Empty;
+ return false;
+ }
+ else
+ {
+ executionStateId = new Guid(data);
+ return true;
+ }
+ }
+
+ public bool TryGetExecutionTransactionState(UInt256 txHash, out Guid executionStateId)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Execution_Transaction)
+ .Add(txHash)
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ if (data == null)
+ {
+ executionStateId = Guid.Empty;
+ return false;
+ }
+ else
+ {
+ executionStateId = new Guid(data);
+ return true;
+ }
+ }
+
+ public bool TryGetTransactionState(UInt256 hash, out TransactionLogState state)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_Transaction)
+ .Add(hash)
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ state = data?.AsSerializable()!;
+ return data != null && data.Length > 0;
+ }
+
+ public bool TryGetStackItemState(Guid stackItemId, out StackItem stackItem)
+ {
+ var key = new KeyBuilder(Prefix_Id, Prefix_StackItem)
+ .Add(stackItemId.ToByteArray())
+ .ToArray();
+ var data = _snapshot.TryGet(key);
+ if (data == null)
+ {
+ stackItem = StackItem.Null;
+ return false;
+ }
+ else
+ {
+ stackItem = BinarySerializer.Deserialize(data, ExecutionEngineLimits.Default);
+ return true;
+ }
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/Models/ApplicationEngineLogModel.cs b/src/Plugins/ApplicationLogs/Store/Models/ApplicationEngineLogModel.cs
new file mode 100644
index 0000000000..112cc49377
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/Models/ApplicationEngineLogModel.cs
@@ -0,0 +1,28 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ApplicationEngineLogModel.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Plugins.Store.States;
+
+namespace Neo.Plugins.Store.Models
+{
+ public class ApplicationEngineLogModel
+ {
+ public UInt160 ScriptHash { get; private init; } = new();
+ public string Message { get; private init; } = string.Empty;
+
+ public static ApplicationEngineLogModel Create(EngineLogState logEventState) =>
+ new()
+ {
+ ScriptHash = logEventState.ScriptHash,
+ Message = logEventState.Message,
+ };
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/Models/BlockchainEventModel.cs b/src/Plugins/ApplicationLogs/Store/Models/BlockchainEventModel.cs
new file mode 100644
index 0000000000..09245db295
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/Models/BlockchainEventModel.cs
@@ -0,0 +1,48 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// BlockchainEventModel.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using ApplicationLogs.Store.States;
+using Neo;
+using Neo.VM.Types;
+
+namespace ApplicationLogs.Store.Models
+{
+ public class BlockchainEventModel
+ {
+ public UInt160 ScriptHash { get; private init; } = new();
+ public string EventName { get; private init; } = string.Empty;
+ public StackItem[] State { get; private init; } = [];
+
+ public static BlockchainEventModel Create(UInt160 scriptHash, string eventName, StackItem[] state) =>
+ new()
+ {
+ ScriptHash = scriptHash,
+ EventName = eventName ?? string.Empty,
+ State = state,
+ };
+
+ public static BlockchainEventModel Create(NotifyLogState notifyLogState, StackItem[] state) =>
+ new()
+ {
+ ScriptHash = notifyLogState.ScriptHash,
+ EventName = notifyLogState.EventName,
+ State = state,
+ };
+
+ public static BlockchainEventModel Create(ContractLogState contractLogState, StackItem[] state) =>
+ new()
+ {
+ ScriptHash = contractLogState.ScriptHash,
+ EventName = contractLogState.EventName,
+ State = state,
+ };
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/Models/BlockchainExecutionModel.cs b/src/Plugins/ApplicationLogs/Store/Models/BlockchainExecutionModel.cs
new file mode 100644
index 0000000000..e31ecd0d0c
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/Models/BlockchainExecutionModel.cs
@@ -0,0 +1,40 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// BlockchainExecutionModel.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using ApplicationLogs.Store.States;
+using Neo.Plugins.Store.Models;
+using Neo.SmartContract;
+using Neo.VM;
+using Neo.VM.Types;
+
+namespace ApplicationLogs.Store.Models
+{
+ public class BlockchainExecutionModel
+ {
+ public TriggerType Trigger { get; private init; } = TriggerType.All;
+ public VMState VmState { get; private init; } = VMState.NONE;
+ public string Exception { get; private init; } = string.Empty;
+ public long GasConsumed { get; private init; } = 0L;
+ public StackItem[] Stack { get; private init; } = [];
+ public BlockchainEventModel[] Notifications { get; set; } = [];
+ public ApplicationEngineLogModel[] Logs { get; set; } = [];
+
+ public static BlockchainExecutionModel Create(TriggerType trigger, ExecutionLogState executionLogState, StackItem[] stack) =>
+ new()
+ {
+ Trigger = trigger,
+ VmState = executionLogState.VmState,
+ Exception = executionLogState.Exception ?? string.Empty,
+ GasConsumed = executionLogState.GasConsumed,
+ Stack = stack,
+ };
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/NeoStore.cs b/src/Plugins/ApplicationLogs/Store/NeoStore.cs
new file mode 100644
index 0000000000..496502869b
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/NeoStore.cs
@@ -0,0 +1,308 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// NeoStore.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using ApplicationLogs.Store.Models;
+using ApplicationLogs.Store.States;
+using Neo;
+using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
+using Neo.Plugins.Store.Models;
+using Neo.Plugins.Store.States;
+using Neo.SmartContract;
+using Neo.VM.Types;
+
+namespace ApplicationLogs.Store
+{
+ public sealed class NeoStore : IDisposable
+ {
+ #region Globals
+
+ private readonly IStore _store;
+ private ISnapshot _blocklogsnapshot;
+
+ #endregion
+
+ #region ctor
+
+ public NeoStore(
+ IStore store)
+ {
+ _store = store;
+ }
+
+ #endregion
+
+ #region IDisposable
+
+ public void Dispose()
+ {
+ _store?.Dispose();
+ GC.SuppressFinalize(this);
+ }
+
+ #endregion
+
+ #region Batching
+
+ public void StartBlockLogBatch()
+ {
+ _blocklogsnapshot?.Dispose();
+ _blocklogsnapshot = _store.GetSnapshot();
+ }
+
+ public void CommitBlockLog() =>
+ _blocklogsnapshot?.Commit();
+
+ #endregion
+
+ #region Store
+
+ public IStore GetStore() => _store;
+
+ #endregion
+
+ #region Contract
+
+ public IReadOnlyCollection<(BlockchainEventModel NotifyLog, UInt256 TxHash)> GetContractLog(UInt160 scriptHash, uint page = 1, uint pageSize = 10)
+ {
+ using var lss = new LogStorageStore(_store.GetSnapshot());
+ var lstModels = new List<(BlockchainEventModel NotifyLog, UInt256 TxHash)>();
+ foreach (var contractState in lss.FindContractState(scriptHash, page, pageSize))
+ lstModels.Add((BlockchainEventModel.Create(contractState, CreateStackItemArray(lss, contractState.StackItemIds)), contractState.TransactionHash));
+ return lstModels;
+ }
+
+ public IReadOnlyCollection<(BlockchainEventModel NotifyLog, UInt256 TxHash)> GetContractLog(UInt160 scriptHash, TriggerType triggerType, uint page = 1, uint pageSize = 10)
+ {
+ using var lss = new LogStorageStore(_store.GetSnapshot());
+ var lstModels = new List<(BlockchainEventModel NotifyLog, UInt256 TxHash)>();
+ foreach (var contractState in lss.FindContractState(scriptHash, triggerType, page, pageSize))
+ lstModels.Add((BlockchainEventModel.Create(contractState, CreateStackItemArray(lss, contractState.StackItemIds)), contractState.TransactionHash));
+ return lstModels;
+ }
+
+ public IReadOnlyCollection<(BlockchainEventModel NotifyLog, UInt256 TxHash)> GetContractLog(UInt160 scriptHash, TriggerType triggerType, string eventName, uint page = 1, uint pageSize = 10)
+ {
+ using var lss = new LogStorageStore(_store.GetSnapshot());
+ var lstModels = new List<(BlockchainEventModel NotifyLog, UInt256 TxHash)>();
+ foreach (var contractState in lss.FindContractState(scriptHash, triggerType, eventName, page, pageSize))
+ lstModels.Add((BlockchainEventModel.Create(contractState, CreateStackItemArray(lss, contractState.StackItemIds)), contractState.TransactionHash));
+ return lstModels;
+ }
+
+ #endregion
+
+ #region Engine
+
+ public void PutTransactionEngineLogState(UInt256 hash, IReadOnlyList logs)
+ {
+ using var lss = new LogStorageStore(_blocklogsnapshot);
+ var ids = new List();
+ foreach (var log in logs)
+ ids.Add(lss.PutEngineState(EngineLogState.Create(log.ScriptHash, log.Message)));
+ lss.PutTransactionEngineState(hash, TransactionEngineLogState.Create(ids.ToArray()));
+ }
+
+ #endregion
+
+ #region Block
+
+ public BlockchainExecutionModel GetBlockLog(UInt256 hash, TriggerType trigger)
+ {
+ using var lss = new LogStorageStore(_store.GetSnapshot());
+ if (lss.TryGetExecutionBlockState(hash, trigger, out var executionBlockStateId) &&
+ lss.TryGetExecutionState(executionBlockStateId, out var executionLogState))
+ {
+ var model = BlockchainExecutionModel.Create(trigger, executionLogState, CreateStackItemArray(lss, executionLogState.StackItemIds));
+ if (lss.TryGetBlockState(hash, trigger, out var blockLogState))
+ {
+ var lstOfEventModel = new List();
+ foreach (var notifyLogItem in blockLogState.NotifyLogIds)
+ {
+ if (lss.TryGetNotifyState(notifyLogItem, out var notifyLogState))
+ lstOfEventModel.Add(BlockchainEventModel.Create(notifyLogState, CreateStackItemArray(lss, notifyLogState.StackItemIds)));
+ }
+ model.Notifications = lstOfEventModel.ToArray();
+ }
+ return model;
+ }
+ return null;
+ }
+
+ public BlockchainExecutionModel GetBlockLog(UInt256 hash, TriggerType trigger, string eventName)
+ {
+ using var lss = new LogStorageStore(_store.GetSnapshot());
+ if (lss.TryGetExecutionBlockState(hash, trigger, out var executionBlockStateId) &&
+ lss.TryGetExecutionState(executionBlockStateId, out var executionLogState))
+ {
+ var model = BlockchainExecutionModel.Create(trigger, executionLogState, CreateStackItemArray(lss, executionLogState.StackItemIds));
+ if (lss.TryGetBlockState(hash, trigger, out var blockLogState))
+ {
+ var lstOfEventModel = new List();
+ foreach (var notifyLogItem in blockLogState.NotifyLogIds)
+ {
+ if (lss.TryGetNotifyState(notifyLogItem, out var notifyLogState))
+ {
+ if (notifyLogState.EventName.Equals(eventName, StringComparison.OrdinalIgnoreCase))
+ lstOfEventModel.Add(BlockchainEventModel.Create(notifyLogState, CreateStackItemArray(lss, notifyLogState.StackItemIds)));
+ }
+ }
+ model.Notifications = lstOfEventModel.ToArray();
+ }
+ return model;
+ }
+ return null;
+ }
+
+ public void PutBlockLog(Block block, IReadOnlyList applicationExecutedList)
+ {
+ foreach (var appExecution in applicationExecutedList)
+ {
+ using var lss = new LogStorageStore(_blocklogsnapshot);
+ var exeStateId = PutExecutionLogBlock(lss, block, appExecution);
+ PutBlockAndTransactionLog(lss, block, appExecution, exeStateId);
+ }
+ }
+
+ private static Guid PutExecutionLogBlock(LogStorageStore logStore, Block block, Blockchain.ApplicationExecuted appExecution)
+ {
+ var exeStateId = logStore.PutExecutionState(ExecutionLogState.Create(appExecution, CreateStackItemIdList(logStore, appExecution)));
+ logStore.PutExecutionBlockState(block.Hash, appExecution.Trigger, exeStateId);
+ return exeStateId;
+ }
+
+ #endregion
+
+ #region Transaction
+
+ public BlockchainExecutionModel GetTransactionLog(UInt256 hash)
+ {
+ using var lss = new LogStorageStore(_store.GetSnapshot());
+ if (lss.TryGetExecutionTransactionState(hash, out var executionTransactionStateId) &&
+ lss.TryGetExecutionState(executionTransactionStateId, out var executionLogState))
+ {
+ var model = BlockchainExecutionModel.Create(TriggerType.Application, executionLogState, CreateStackItemArray(lss, executionLogState.StackItemIds));
+ if (lss.TryGetTransactionState(hash, out var transactionLogState))
+ {
+ var lstOfEventModel = new List();
+ foreach (var notifyLogItem in transactionLogState.NotifyLogIds)
+ {
+ if (lss.TryGetNotifyState(notifyLogItem, out var notifyLogState))
+ lstOfEventModel.Add(BlockchainEventModel.Create(notifyLogState, CreateStackItemArray(lss, notifyLogState.StackItemIds)));
+ }
+ model.Notifications = lstOfEventModel.ToArray();
+
+ if (lss.TryGetTransactionEngineState(hash, out var transactionEngineLogState))
+ {
+ var lstOfLogs = new List();
+ foreach (var logItem in transactionEngineLogState.LogIds)
+ {
+ if (lss.TryGetEngineState(logItem, out var engineLogState))
+ lstOfLogs.Add(ApplicationEngineLogModel.Create(engineLogState));
+ }
+ model.Logs = lstOfLogs.ToArray();
+ }
+ }
+ return model;
+ }
+ return null;
+ }
+
+ public BlockchainExecutionModel GetTransactionLog(UInt256 hash, string eventName)
+ {
+ using var lss = new LogStorageStore(_store.GetSnapshot());
+ if (lss.TryGetExecutionTransactionState(hash, out var executionTransactionStateId) &&
+ lss.TryGetExecutionState(executionTransactionStateId, out var executionLogState))
+ {
+ var model = BlockchainExecutionModel.Create(TriggerType.Application, executionLogState, CreateStackItemArray(lss, executionLogState.StackItemIds));
+ if (lss.TryGetTransactionState(hash, out var transactionLogState))
+ {
+ var lstOfEventModel = new List();
+ foreach (var notifyLogItem in transactionLogState.NotifyLogIds)
+ {
+ if (lss.TryGetNotifyState(notifyLogItem, out var notifyLogState))
+ {
+ if (notifyLogState.EventName.Equals(eventName, StringComparison.OrdinalIgnoreCase))
+ lstOfEventModel.Add(BlockchainEventModel.Create(notifyLogState, CreateStackItemArray(lss, notifyLogState.StackItemIds)));
+ }
+ }
+ model.Notifications = lstOfEventModel.ToArray();
+
+ if (lss.TryGetTransactionEngineState(hash, out var transactionEngineLogState))
+ {
+ var lstOfLogs = new List();
+ foreach (var logItem in transactionEngineLogState.LogIds)
+ {
+ if (lss.TryGetEngineState(logItem, out var engineLogState))
+ lstOfLogs.Add(ApplicationEngineLogModel.Create(engineLogState));
+ }
+ model.Logs = lstOfLogs.ToArray();
+ }
+ }
+ return model;
+ }
+ return null;
+ }
+
+ private static void PutBlockAndTransactionLog(LogStorageStore logStore, Block block, Blockchain.ApplicationExecuted appExecution, Guid executionStateId)
+ {
+ if (appExecution.Transaction != null)
+ logStore.PutExecutionTransactionState(appExecution.Transaction.Hash, executionStateId); // For looking up execution log by transaction hash
+
+ var lstNotifyLogIds = new List();
+ for (uint i = 0; i < appExecution.Notifications.Length; i++)
+ {
+ var notifyItem = appExecution.Notifications[i];
+ var stackItemStateIds = CreateStackItemIdList(logStore, notifyItem); // Save notify stack items
+ logStore.PutContractState(notifyItem.ScriptHash, block.Timestamp, i, // save notifylog for the contracts
+ ContractLogState.Create(appExecution, notifyItem, stackItemStateIds));
+ lstNotifyLogIds.Add(logStore.PutNotifyState(NotifyLogState.Create(notifyItem, stackItemStateIds)));
+ }
+
+ if (appExecution.Transaction != null)
+ logStore.PutTransactionState(appExecution.Transaction.Hash, TransactionLogState.Create(lstNotifyLogIds.ToArray()));
+
+ logStore.PutBlockState(block.Hash, appExecution.Trigger, BlockLogState.Create(lstNotifyLogIds.ToArray()));
+ }
+
+ #endregion
+
+ #region StackItem
+
+ private static StackItem[] CreateStackItemArray(LogStorageStore logStore, Guid[] stackItemIds)
+ {
+ var lstStackItems = new List();
+ foreach (var stackItemId in stackItemIds)
+ if (logStore.TryGetStackItemState(stackItemId, out var stackItem))
+ lstStackItems.Add(stackItem);
+ return lstStackItems.ToArray();
+ }
+
+ private static Guid[] CreateStackItemIdList(LogStorageStore logStore, Blockchain.ApplicationExecuted appExecution)
+ {
+ var lstStackItemIds = new List();
+ foreach (var stackItem in appExecution.Stack)
+ lstStackItemIds.Add(logStore.PutStackItemState(stackItem));
+ return lstStackItemIds.ToArray();
+ }
+
+ private static Guid[] CreateStackItemIdList(LogStorageStore logStore, NotifyEventArgs notifyEventArgs)
+ {
+ var lstStackItemIds = new List();
+ foreach (var stackItem in notifyEventArgs.State)
+ lstStackItemIds.Add(logStore.PutStackItemState(stackItem));
+ return lstStackItemIds.ToArray();
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/States/BlockLogState.cs b/src/Plugins/ApplicationLogs/Store/States/BlockLogState.cs
new file mode 100644
index 0000000000..dcbb58b6e6
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/States/BlockLogState.cs
@@ -0,0 +1,72 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// BlockLogState.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo;
+using Neo.IO;
+
+namespace ApplicationLogs.Store.States
+{
+ public class BlockLogState : ISerializable, IEquatable
+ {
+ public Guid[] NotifyLogIds { get; private set; } = [];
+
+ public static BlockLogState Create(Guid[] notifyLogIds) =>
+ new()
+ {
+ NotifyLogIds = notifyLogIds,
+ };
+
+ #region ISerializable
+
+ public virtual int Size =>
+ sizeof(uint) +
+ NotifyLogIds.Sum(s => s.ToByteArray().GetVarSize());
+
+ public virtual void Deserialize(ref MemoryReader reader)
+ {
+ // It should be safe because it filled from a block's notifications.
+ uint aLen = reader.ReadUInt32();
+ NotifyLogIds = new Guid[aLen];
+ for (int i = 0; i < aLen; i++)
+ NotifyLogIds[i] = new Guid(reader.ReadVarMemory().Span);
+ }
+
+ public virtual void Serialize(BinaryWriter writer)
+ {
+ writer.Write((uint)NotifyLogIds.Length);
+ for (int i = 0; i < NotifyLogIds.Length; i++)
+ writer.WriteVarBytes(NotifyLogIds[i].ToByteArray());
+ }
+
+ #endregion
+
+ #region IEquatable
+
+ public bool Equals(BlockLogState other) =>
+ NotifyLogIds.SequenceEqual(other.NotifyLogIds);
+
+ public override bool Equals(object obj)
+ {
+ if (ReferenceEquals(this, obj)) return true;
+ return Equals(obj as BlockLogState);
+ }
+
+ public override int GetHashCode()
+ {
+ var h = new HashCode();
+ foreach (var id in NotifyLogIds)
+ h.Add(id);
+ return h.ToHashCode();
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/States/ContractLogState.cs b/src/Plugins/ApplicationLogs/Store/States/ContractLogState.cs
new file mode 100644
index 0000000000..0987e86e67
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/States/ContractLogState.cs
@@ -0,0 +1,74 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ContractLogState.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo;
+using Neo.IO;
+using Neo.Ledger;
+using Neo.SmartContract;
+
+namespace ApplicationLogs.Store.States
+{
+ public class ContractLogState : NotifyLogState, IEquatable
+ {
+ public UInt256 TransactionHash { get; private set; } = new();
+ public TriggerType Trigger { get; private set; } = TriggerType.All;
+
+ public static ContractLogState Create(Blockchain.ApplicationExecuted applicationExecuted, NotifyEventArgs notifyEventArgs, Guid[] stackItemIds) =>
+ new()
+ {
+ TransactionHash = applicationExecuted.Transaction?.Hash ?? new(),
+ ScriptHash = notifyEventArgs.ScriptHash,
+ Trigger = applicationExecuted.Trigger,
+ EventName = notifyEventArgs.EventName,
+ StackItemIds = stackItemIds,
+ };
+
+ #region ISerializable
+
+ public override int Size =>
+ TransactionHash.Size +
+ sizeof(byte) +
+ base.Size;
+
+ public override void Deserialize(ref MemoryReader reader)
+ {
+ TransactionHash.Deserialize(ref reader);
+ Trigger = (TriggerType)reader.ReadByte();
+ base.Deserialize(ref reader);
+ }
+
+ public override void Serialize(BinaryWriter writer)
+ {
+ TransactionHash.Serialize(writer);
+ writer.Write((byte)Trigger);
+ base.Serialize(writer);
+ }
+
+ #endregion
+
+ #region IEquatable
+
+ public bool Equals(ContractLogState other) =>
+ Trigger == other.Trigger && EventName == other.EventName &&
+ TransactionHash == other.TransactionHash && StackItemIds.SequenceEqual(other.StackItemIds);
+
+ public override bool Equals(object obj)
+ {
+ if (ReferenceEquals(this, obj)) return true;
+ return Equals(obj as ContractLogState);
+ }
+
+ public override int GetHashCode() =>
+ HashCode.Combine(TransactionHash, Trigger, base.GetHashCode());
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/States/EngineLogState.cs b/src/Plugins/ApplicationLogs/Store/States/EngineLogState.cs
new file mode 100644
index 0000000000..8b07855253
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/States/EngineLogState.cs
@@ -0,0 +1,66 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// EngineLogState.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+
+namespace Neo.Plugins.Store.States
+{
+ public class EngineLogState : ISerializable, IEquatable
+ {
+ public UInt160 ScriptHash { get; private set; } = new();
+ public string Message { get; private set; } = string.Empty;
+
+ public static EngineLogState Create(UInt160 scriptHash, string message) =>
+ new()
+ {
+ ScriptHash = scriptHash,
+ Message = message,
+ };
+
+ #region ISerializable
+
+ public virtual int Size =>
+ ScriptHash.Size +
+ Message.GetVarSize();
+
+ public virtual void Deserialize(ref MemoryReader reader)
+ {
+ ScriptHash.Deserialize(ref reader);
+ // It should be safe because it filled from a transaction's logs.
+ Message = reader.ReadVarString();
+ }
+
+ public virtual void Serialize(BinaryWriter writer)
+ {
+ ScriptHash.Serialize(writer);
+ writer.WriteVarString(Message ?? string.Empty);
+ }
+
+ #endregion
+
+ #region IEquatable
+
+ public bool Equals(EngineLogState other) =>
+ ScriptHash == other.ScriptHash &&
+ Message == other.Message;
+
+ public override bool Equals(object obj)
+ {
+ if (ReferenceEquals(this, obj)) return true;
+ return Equals(obj as EngineLogState);
+ }
+
+ public override int GetHashCode() =>
+ HashCode.Combine(ScriptHash, Message);
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/States/ExecutionLogState.cs b/src/Plugins/ApplicationLogs/Store/States/ExecutionLogState.cs
new file mode 100644
index 0000000000..44f8a74b49
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/States/ExecutionLogState.cs
@@ -0,0 +1,94 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ExecutionLogState.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using Neo.Ledger;
+using Neo.VM;
+
+namespace ApplicationLogs.Store.States
+{
+ public class ExecutionLogState : ISerializable, IEquatable
+ {
+ public VMState VmState { get; private set; } = VMState.NONE;
+ public string Exception { get; private set; } = string.Empty;
+ public long GasConsumed { get; private set; } = 0L;
+ public Guid[] StackItemIds { get; private set; } = [];
+
+ public static ExecutionLogState Create(Blockchain.ApplicationExecuted appExecution, Guid[] stackItemIds) =>
+ new()
+ {
+ VmState = appExecution.VMState,
+ Exception = appExecution.Exception?.InnerException?.Message ?? appExecution.Exception?.Message!,
+ GasConsumed = appExecution.GasConsumed,
+ StackItemIds = stackItemIds,
+ };
+
+ #region ISerializable
+
+ public int Size =>
+ sizeof(byte) +
+ Exception.GetVarSize() +
+ sizeof(long) +
+ sizeof(uint) +
+ StackItemIds.Sum(s => s.ToByteArray().GetVarSize());
+
+ public void Deserialize(ref MemoryReader reader)
+ {
+ VmState = (VMState)reader.ReadByte();
+ Exception = reader.ReadVarString();
+ GasConsumed = reader.ReadInt64();
+
+ // It should be safe because it filled from a transaction's stack.
+ uint aLen = reader.ReadUInt32();
+ StackItemIds = new Guid[aLen];
+ for (int i = 0; i < aLen; i++)
+ StackItemIds[i] = new Guid(reader.ReadVarMemory().Span);
+ }
+
+ public void Serialize(BinaryWriter writer)
+ {
+ writer.Write((byte)VmState);
+ writer.WriteVarString(Exception ?? string.Empty);
+ writer.Write(GasConsumed);
+
+ writer.Write((uint)StackItemIds.Length);
+ for (int i = 0; i < StackItemIds.Length; i++)
+ writer.WriteVarBytes(StackItemIds[i].ToByteArray());
+ }
+
+ #endregion
+
+ #region IEquatable
+
+ public bool Equals(ExecutionLogState other) =>
+ VmState == other.VmState && Exception == other.Exception &&
+ GasConsumed == other.GasConsumed && StackItemIds.SequenceEqual(other.StackItemIds);
+
+ public override bool Equals(object obj)
+ {
+ if (ReferenceEquals(this, obj)) return true;
+ return Equals(obj as ExecutionLogState);
+ }
+
+ public override int GetHashCode()
+ {
+ var h = new HashCode();
+ h.Add(VmState);
+ h.Add(Exception);
+ h.Add(GasConsumed);
+ foreach (var id in StackItemIds)
+ h.Add(id);
+ return h.ToHashCode();
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/States/NotifyLogState.cs b/src/Plugins/ApplicationLogs/Store/States/NotifyLogState.cs
new file mode 100644
index 0000000000..20fbd9e456
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/States/NotifyLogState.cs
@@ -0,0 +1,87 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// NotifyLogState.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo;
+using Neo.IO;
+using Neo.SmartContract;
+
+namespace ApplicationLogs.Store.States
+{
+ public class NotifyLogState : ISerializable, IEquatable
+ {
+ public UInt160 ScriptHash { get; protected set; } = new();
+ public string EventName { get; protected set; } = string.Empty;
+ public Guid[] StackItemIds { get; protected set; } = [];
+
+ public static NotifyLogState Create(NotifyEventArgs notifyItem, Guid[] stackItemsIds) =>
+ new()
+ {
+ ScriptHash = notifyItem.ScriptHash,
+ EventName = notifyItem.EventName,
+ StackItemIds = stackItemsIds,
+ };
+
+ #region ISerializable
+
+ public virtual int Size =>
+ ScriptHash.Size +
+ EventName.GetVarSize() +
+ StackItemIds.Sum(s => s.ToByteArray().GetVarSize());
+
+ public virtual void Deserialize(ref MemoryReader reader)
+ {
+ ScriptHash.Deserialize(ref reader);
+ EventName = reader.ReadVarString();
+
+ // It should be safe because it filled from a transaction's notifications.
+ uint aLen = reader.ReadUInt32();
+ StackItemIds = new Guid[aLen];
+ for (var i = 0; i < aLen; i++)
+ StackItemIds[i] = new Guid(reader.ReadVarMemory().Span);
+ }
+
+ public virtual void Serialize(BinaryWriter writer)
+ {
+ ScriptHash.Serialize(writer);
+ writer.WriteVarString(EventName ?? string.Empty);
+
+ writer.Write((uint)StackItemIds.Length);
+ for (var i = 0; i < StackItemIds.Length; i++)
+ writer.WriteVarBytes(StackItemIds[i].ToByteArray());
+ }
+
+ #endregion
+
+ #region IEquatable
+
+ public bool Equals(NotifyLogState other) =>
+ EventName == other.EventName && ScriptHash == other.ScriptHash &&
+ StackItemIds.SequenceEqual(other.StackItemIds);
+
+ public override bool Equals(object obj)
+ {
+ if (ReferenceEquals(this, obj)) return true;
+ return Equals(obj as NotifyLogState);
+ }
+
+ public override int GetHashCode()
+ {
+ var h = new HashCode();
+ h.Add(ScriptHash);
+ h.Add(EventName);
+ foreach (var id in StackItemIds)
+ h.Add(id);
+ return h.ToHashCode();
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/States/TransactionEngineLogState.cs b/src/Plugins/ApplicationLogs/Store/States/TransactionEngineLogState.cs
new file mode 100644
index 0000000000..8b32867b66
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/States/TransactionEngineLogState.cs
@@ -0,0 +1,71 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// TransactionEngineLogState.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+
+namespace Neo.Plugins.Store.States
+{
+ public class TransactionEngineLogState : ISerializable, IEquatable
+ {
+ public Guid[] LogIds { get; private set; } = Array.Empty();
+
+ public static TransactionEngineLogState Create(Guid[] logIds) =>
+ new()
+ {
+ LogIds = logIds,
+ };
+
+ #region ISerializable
+
+ public virtual int Size =>
+ sizeof(uint) +
+ LogIds.Sum(s => s.ToByteArray().GetVarSize());
+
+ public virtual void Deserialize(ref MemoryReader reader)
+ {
+ // It should be safe because it filled from a transaction's logs.
+ uint aLen = reader.ReadUInt32();
+ LogIds = new Guid[aLen];
+ for (int i = 0; i < aLen; i++)
+ LogIds[i] = new Guid(reader.ReadVarMemory().Span);
+ }
+
+ public virtual void Serialize(BinaryWriter writer)
+ {
+ writer.Write((uint)LogIds.Length);
+ for (int i = 0; i < LogIds.Length; i++)
+ writer.WriteVarBytes(LogIds[i].ToByteArray());
+ }
+
+ #endregion
+
+ #region IEquatable
+
+ public bool Equals(TransactionEngineLogState other) =>
+ LogIds.SequenceEqual(other.LogIds);
+
+ public override bool Equals(object obj)
+ {
+ if (ReferenceEquals(this, obj)) return true;
+ return Equals(obj as TransactionEngineLogState);
+ }
+
+ public override int GetHashCode()
+ {
+ var h = new HashCode();
+ foreach (var id in LogIds)
+ h.Add(id);
+ return h.ToHashCode();
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/Store/States/TransactionLogState.cs b/src/Plugins/ApplicationLogs/Store/States/TransactionLogState.cs
new file mode 100644
index 0000000000..b40d3244d0
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/Store/States/TransactionLogState.cs
@@ -0,0 +1,72 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// TransactionLogState.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo;
+using Neo.IO;
+
+namespace ApplicationLogs.Store.States
+{
+ public class TransactionLogState : ISerializable, IEquatable
+ {
+ public Guid[] NotifyLogIds { get; private set; } = Array.Empty();
+
+ public static TransactionLogState Create(Guid[] notifyLogIds) =>
+ new()
+ {
+ NotifyLogIds = notifyLogIds,
+ };
+
+ #region ISerializable
+
+ public virtual int Size =>
+ sizeof(uint) +
+ NotifyLogIds.Sum(s => s.ToByteArray().GetVarSize());
+
+ public virtual void Deserialize(ref MemoryReader reader)
+ {
+ // It should be safe because it filled from a transaction's notifications.
+ uint aLen = reader.ReadUInt32();
+ NotifyLogIds = new Guid[aLen];
+ for (int i = 0; i < aLen; i++)
+ NotifyLogIds[i] = new Guid(reader.ReadVarMemory().Span);
+ }
+
+ public virtual void Serialize(BinaryWriter writer)
+ {
+ writer.Write((uint)NotifyLogIds.Length);
+ for (int i = 0; i < NotifyLogIds.Length; i++)
+ writer.WriteVarBytes(NotifyLogIds[i].ToByteArray());
+ }
+
+ #endregion
+
+ #region IEquatable
+
+ public bool Equals(TransactionLogState other) =>
+ NotifyLogIds.SequenceEqual(other.NotifyLogIds);
+
+ public override bool Equals(object obj)
+ {
+ if (ReferenceEquals(this, obj)) return true;
+ return Equals(obj as TransactionLogState);
+ }
+
+ public override int GetHashCode()
+ {
+ var h = new HashCode();
+ foreach (var id in NotifyLogIds)
+ h.Add(id);
+ return h.ToHashCode();
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Plugins/ApplicationLogs/config.json b/src/Plugins/ApplicationLogs/config.json
new file mode 100644
index 0000000000..af601bc81e
--- /dev/null
+++ b/src/Plugins/ApplicationLogs/config.json
@@ -0,0 +1,11 @@
+{
+ "PluginConfiguration": {
+ "Path": "ApplicationLogs_{0}",
+ "Network": 860833102,
+ "MaxStackSize": 65535,
+ "Debug": false
+ },
+ "Dependency": [
+ "RpcServer"
+ ]
+}
diff --git a/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.Get.cs b/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.Get.cs
new file mode 100644
index 0000000000..b54b6eca1e
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.Get.cs
@@ -0,0 +1,117 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ConsensusContext.Get.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Network.P2P.Payloads;
+using Neo.SmartContract;
+using Neo.Wallets;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using static Neo.Consensus.RecoveryMessage;
+
+namespace Neo.Consensus
+{
+ partial class ConsensusContext
+ {
+ public ConsensusMessage GetMessage(ExtensiblePayload payload)
+ {
+ if (payload is null) return null;
+ if (!cachedMessages.TryGetValue(payload.Hash, out ConsensusMessage message))
+ cachedMessages.Add(payload.Hash, message = ConsensusMessage.DeserializeFrom(payload.Data));
+ return message;
+ }
+
+ public T GetMessage(ExtensiblePayload payload) where T : ConsensusMessage
+ {
+ return (T)GetMessage(payload);
+ }
+
+ private ChangeViewPayloadCompact GetChangeViewPayloadCompact(ExtensiblePayload payload)
+ {
+ ChangeView message = GetMessage(payload);
+ return new ChangeViewPayloadCompact
+ {
+ ValidatorIndex = message.ValidatorIndex,
+ OriginalViewNumber = message.ViewNumber,
+ Timestamp = message.Timestamp,
+ InvocationScript = payload.Witness.InvocationScript
+ };
+ }
+
+ private CommitPayloadCompact GetCommitPayloadCompact(ExtensiblePayload payload)
+ {
+ Commit message = GetMessage(payload);
+ return new CommitPayloadCompact
+ {
+ ViewNumber = message.ViewNumber,
+ ValidatorIndex = message.ValidatorIndex,
+ Signature = message.Signature,
+ InvocationScript = payload.Witness.InvocationScript
+ };
+ }
+
+ private PreparationPayloadCompact GetPreparationPayloadCompact(ExtensiblePayload payload)
+ {
+ return new PreparationPayloadCompact
+ {
+ ValidatorIndex = GetMessage(payload).ValidatorIndex,
+ InvocationScript = payload.Witness.InvocationScript
+ };
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public byte GetPrimaryIndex(byte viewNumber)
+ {
+ int p = ((int)Block.Index - viewNumber) % Validators.Length;
+ return p >= 0 ? (byte)p : (byte)(p + Validators.Length);
+ }
+
+ public UInt160 GetSender(int index)
+ {
+ return Contract.CreateSignatureRedeemScript(Validators[index]).ToScriptHash();
+ }
+
+ ///
+ /// Return the expected block size
+ ///
+ public int GetExpectedBlockSize()
+ {
+ return GetExpectedBlockSizeWithoutTransactions(Transactions.Count) + // Base size
+ Transactions.Values.Sum(u => u.Size); // Sum Txs
+ }
+
+ ///
+ /// Return the expected block system fee
+ ///
+ public long GetExpectedBlockSystemFee()
+ {
+ return Transactions.Values.Sum(u => u.SystemFee); // Sum Txs
+ }
+
+ ///
+ /// Return the expected block size without txs
+ ///
+ /// Expected transactions
+ internal int GetExpectedBlockSizeWithoutTransactions(int expectedTransactions)
+ {
+ return
+ sizeof(uint) + // Version
+ UInt256.Length + // PrevHash
+ UInt256.Length + // MerkleRoot
+ sizeof(ulong) + // Timestamp
+ sizeof(ulong) + // Nonce
+ sizeof(uint) + // Index
+ sizeof(byte) + // PrimaryIndex
+ UInt160.Length + // NextConsensus
+ 1 + _witnessSize + // Witness
+ IO.Helper.GetVarSize(expectedTransactions);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.MakePayload.cs b/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.MakePayload.cs
new file mode 100644
index 0000000000..a761cbafb0
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.MakePayload.cs
@@ -0,0 +1,176 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ConsensusContext.MakePayload.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
+using Neo.SmartContract;
+using Neo.Wallets;
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.Linq;
+using static Neo.Consensus.RecoveryMessage;
+
+namespace Neo.Consensus
+{
+ partial class ConsensusContext
+ {
+ public ExtensiblePayload MakeChangeView(ChangeViewReason reason)
+ {
+ return ChangeViewPayloads[MyIndex] = MakeSignedPayload(new ChangeView
+ {
+ Reason = reason,
+ Timestamp = TimeProvider.Current.UtcNow.ToTimestampMS()
+ });
+ }
+
+ public ExtensiblePayload MakeCommit()
+ {
+ return CommitPayloads[MyIndex] ?? (CommitPayloads[MyIndex] = MakeSignedPayload(new Commit
+ {
+ Signature = EnsureHeader().Sign(keyPair, neoSystem.Settings.Network)
+ }));
+ }
+
+ private ExtensiblePayload MakeSignedPayload(ConsensusMessage message)
+ {
+ message.BlockIndex = Block.Index;
+ message.ValidatorIndex = (byte)MyIndex;
+ message.ViewNumber = ViewNumber;
+ ExtensiblePayload payload = CreatePayload(message, null);
+ SignPayload(payload);
+ return payload;
+ }
+
+ private void SignPayload(ExtensiblePayload payload)
+ {
+ ContractParametersContext sc;
+ try
+ {
+ sc = new ContractParametersContext(neoSystem.StoreView, payload, dbftSettings.Network);
+ wallet.Sign(sc);
+ }
+ catch (InvalidOperationException exception)
+ {
+ Utility.Log(nameof(ConsensusContext), LogLevel.Debug, exception.ToString());
+ return;
+ }
+ payload.Witness = sc.GetWitnesses()[0];
+ }
+
+ ///
+ /// Prevent that block exceed the max size
+ ///
+ /// Ordered transactions
+ internal void EnsureMaxBlockLimitation(IEnumerable txs)
+ {
+ uint maxTransactionsPerBlock = neoSystem.Settings.MaxTransactionsPerBlock;
+
+ // Limit Speaker proposal to the limit `MaxTransactionsPerBlock` or all available transactions of the mempool
+ txs = txs.Take((int)maxTransactionsPerBlock);
+
+ List hashes = new List();
+ Transactions = new Dictionary();
+ VerificationContext = new TransactionVerificationContext();
+
+ // Expected block size
+ var blockSize = GetExpectedBlockSizeWithoutTransactions(txs.Count());
+ var blockSystemFee = 0L;
+
+ // Iterate transaction until reach the size or maximum system fee
+ foreach (Transaction tx in txs)
+ {
+ // Check if maximum block size has been already exceeded with the current selected set
+ blockSize += tx.Size;
+ if (blockSize > dbftSettings.MaxBlockSize) break;
+
+ // Check if maximum block system fee has been already exceeded with the current selected set
+ blockSystemFee += tx.SystemFee;
+ if (blockSystemFee > dbftSettings.MaxBlockSystemFee) break;
+
+ hashes.Add(tx.Hash);
+ Transactions.Add(tx.Hash, tx);
+ VerificationContext.AddTransaction(tx);
+ }
+
+ TransactionHashes = hashes.ToArray();
+ }
+
+ public ExtensiblePayload MakePrepareRequest()
+ {
+ EnsureMaxBlockLimitation(neoSystem.MemPool.GetSortedVerifiedTransactions());
+ Block.Header.Timestamp = Math.Max(TimeProvider.Current.UtcNow.ToTimestampMS(), PrevHeader.Timestamp + 1);
+ Block.Header.Nonce = GetNonce();
+ return PreparationPayloads[MyIndex] = MakeSignedPayload(new PrepareRequest
+ {
+ Version = Block.Version,
+ PrevHash = Block.PrevHash,
+ Timestamp = Block.Timestamp,
+ Nonce = Block.Nonce,
+ TransactionHashes = TransactionHashes
+ });
+ }
+
+ public ExtensiblePayload MakeRecoveryRequest()
+ {
+ return MakeSignedPayload(new RecoveryRequest
+ {
+ Timestamp = TimeProvider.Current.UtcNow.ToTimestampMS()
+ });
+ }
+
+ public ExtensiblePayload MakeRecoveryMessage()
+ {
+ PrepareRequest prepareRequestMessage = null;
+ if (TransactionHashes != null)
+ {
+ prepareRequestMessage = new PrepareRequest
+ {
+ Version = Block.Version,
+ PrevHash = Block.PrevHash,
+ ViewNumber = ViewNumber,
+ Timestamp = Block.Timestamp,
+ Nonce = Block.Nonce,
+ BlockIndex = Block.Index,
+ ValidatorIndex = Block.PrimaryIndex,
+ TransactionHashes = TransactionHashes
+ };
+ }
+ return MakeSignedPayload(new RecoveryMessage
+ {
+ ChangeViewMessages = LastChangeViewPayloads.Where(p => p != null).Select(p => GetChangeViewPayloadCompact(p)).Take(M).ToDictionary(p => p.ValidatorIndex),
+ PrepareRequestMessage = prepareRequestMessage,
+ // We only need a PreparationHash set if we don't have the PrepareRequest information.
+ PreparationHash = TransactionHashes == null ? PreparationPayloads.Where(p => p != null).GroupBy(p => GetMessage(p).PreparationHash, (k, g) => new { Hash = k, Count = g.Count() }).OrderByDescending(p => p.Count).Select(p => p.Hash).FirstOrDefault() : null,
+ PreparationMessages = PreparationPayloads.Where(p => p != null).Select(p => GetPreparationPayloadCompact(p)).ToDictionary(p => p.ValidatorIndex),
+ CommitMessages = CommitSent
+ ? CommitPayloads.Where(p => p != null).Select(p => GetCommitPayloadCompact(p)).ToDictionary(p => p.ValidatorIndex)
+ : new Dictionary()
+ });
+ }
+
+ public ExtensiblePayload MakePrepareResponse()
+ {
+ return PreparationPayloads[MyIndex] = MakeSignedPayload(new PrepareResponse
+ {
+ PreparationHash = PreparationPayloads[Block.PrimaryIndex].Hash
+ });
+ }
+
+ private static ulong GetNonce()
+ {
+ Random _random = new();
+ Span buffer = stackalloc byte[8];
+ _random.NextBytes(buffer);
+ return BinaryPrimitives.ReadUInt64LittleEndian(buffer);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.cs b/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.cs
new file mode 100644
index 0000000000..35044e4fb8
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Consensus/ConsensusContext.cs
@@ -0,0 +1,323 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ConsensusContext.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Cryptography;
+using Neo.Cryptography.ECC;
+using Neo.IO;
+using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using Neo.VM;
+using Neo.Wallets;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Neo.Consensus
+{
+ public partial class ConsensusContext : IDisposable, ISerializable
+ {
+ ///
+ /// Key for saving consensus state.
+ ///
+ private static readonly byte[] ConsensusStateKey = { 0xf4 };
+
+ public Block Block;
+ public byte ViewNumber;
+ public ECPoint[] Validators;
+ public int MyIndex;
+ public UInt256[] TransactionHashes;
+ public Dictionary Transactions;
+ public ExtensiblePayload[] PreparationPayloads;
+ public ExtensiblePayload[] CommitPayloads;
+ public ExtensiblePayload[] ChangeViewPayloads;
+ public ExtensiblePayload[] LastChangeViewPayloads;
+ // LastSeenMessage array stores the height of the last seen message, for each validator.
+ // if this node never heard from validator i, LastSeenMessage[i] will be -1.
+ public Dictionary LastSeenMessage { get; private set; }
+
+ ///
+ /// Store all verified unsorted transactions' senders' fee currently in the consensus context.
+ ///
+ public TransactionVerificationContext VerificationContext = new();
+
+ public SnapshotCache Snapshot { get; private set; }
+ private KeyPair keyPair;
+ private int _witnessSize;
+ private readonly NeoSystem neoSystem;
+ private readonly Settings dbftSettings;
+ private readonly Wallet wallet;
+ private readonly IStore store;
+ private Dictionary cachedMessages;
+
+ public int F => (Validators.Length - 1) / 3;
+ public int M => Validators.Length - F;
+ public bool IsPrimary => MyIndex == Block.PrimaryIndex;
+ public bool IsBackup => MyIndex >= 0 && MyIndex != Block.PrimaryIndex;
+ public bool WatchOnly => MyIndex < 0;
+ public Header PrevHeader => NativeContract.Ledger.GetHeader(Snapshot, Block.PrevHash);
+ public int CountCommitted => CommitPayloads.Count(p => p != null);
+ public int CountFailed
+ {
+ get
+ {
+ if (LastSeenMessage == null) return 0;
+ return Validators.Count(p => !LastSeenMessage.TryGetValue(p, out var value) || value < (Block.Index - 1));
+ }
+ }
+ public bool ValidatorsChanged
+ {
+ get
+ {
+ if (NativeContract.Ledger.CurrentIndex(Snapshot) == 0) return false;
+ UInt256 hash = NativeContract.Ledger.CurrentHash(Snapshot);
+ TrimmedBlock currentBlock = NativeContract.Ledger.GetTrimmedBlock(Snapshot, hash);
+ TrimmedBlock previousBlock = NativeContract.Ledger.GetTrimmedBlock(Snapshot, currentBlock.Header.PrevHash);
+ return currentBlock.Header.NextConsensus != previousBlock.Header.NextConsensus;
+ }
+ }
+
+ #region Consensus States
+ public bool RequestSentOrReceived => PreparationPayloads[Block.PrimaryIndex] != null;
+ public bool ResponseSent => !WatchOnly && PreparationPayloads[MyIndex] != null;
+ public bool CommitSent => !WatchOnly && CommitPayloads[MyIndex] != null;
+ public bool BlockSent => Block.Transactions != null;
+ public bool ViewChanging => !WatchOnly && GetMessage(ChangeViewPayloads[MyIndex])?.NewViewNumber > ViewNumber;
+ // NotAcceptingPayloadsDueToViewChanging imposes nodes to not accept some payloads if View is Changing,
+ // i.e: OnTransaction function will not process any transaction; OnPrepareRequestReceived will also return;
+ // as well as OnPrepareResponseReceived and also similar logic for recovering.
+ // On the other hand, if more than MoreThanFNodesCommittedOrLost is true, we keep accepting those payloads.
+ // This helps the node to still commit, even while almost changing view.
+ public bool NotAcceptingPayloadsDueToViewChanging => ViewChanging && !MoreThanFNodesCommittedOrLost;
+ // A possible attack can happen if the last node to commit is malicious and either sends change view after his
+ // commit to stall nodes in a higher view, or if he refuses to send recovery messages. In addition, if a node
+ // asking change views loses network or crashes and comes back when nodes are committed in more than one higher
+ // numbered view, it is possible for the node accepting recovery to commit in any of the higher views, thus
+ // potentially splitting nodes among views and stalling the network.
+ public bool MoreThanFNodesCommittedOrLost => (CountCommitted + CountFailed) > F;
+ #endregion
+
+ public int Size => throw new NotImplementedException();
+
+ public ConsensusContext(NeoSystem neoSystem, Settings settings, Wallet wallet)
+ {
+ this.wallet = wallet;
+ this.neoSystem = neoSystem;
+ dbftSettings = settings;
+ store = neoSystem.LoadStore(settings.RecoveryLogs);
+ }
+
+ public Block CreateBlock()
+ {
+ EnsureHeader();
+ Contract contract = Contract.CreateMultiSigContract(M, Validators);
+ ContractParametersContext sc = new ContractParametersContext(neoSystem.StoreView, Block.Header, dbftSettings.Network);
+ for (int i = 0, j = 0; i < Validators.Length && j < M; i++)
+ {
+ if (GetMessage(CommitPayloads[i])?.ViewNumber != ViewNumber) continue;
+ sc.AddSignature(contract, Validators[i], GetMessage(CommitPayloads[i]).Signature.ToArray());
+ j++;
+ }
+ Block.Header.Witness = sc.GetWitnesses()[0];
+ Block.Transactions = TransactionHashes.Select(p => Transactions[p]).ToArray();
+ return Block;
+ }
+
+ public ExtensiblePayload CreatePayload(ConsensusMessage message, ReadOnlyMemory invocationScript = default)
+ {
+ ExtensiblePayload payload = new ExtensiblePayload
+ {
+ Category = "dBFT",
+ ValidBlockStart = 0,
+ ValidBlockEnd = message.BlockIndex,
+ Sender = GetSender(message.ValidatorIndex),
+ Data = message.ToArray(),
+ Witness = invocationScript.IsEmpty ? null : new Witness
+ {
+ InvocationScript = invocationScript,
+ VerificationScript = Contract.CreateSignatureRedeemScript(Validators[message.ValidatorIndex])
+ }
+ };
+ cachedMessages.TryAdd(payload.Hash, message);
+ return payload;
+ }
+
+ public void Dispose()
+ {
+ Snapshot?.Dispose();
+ }
+
+ public Block EnsureHeader()
+ {
+ if (TransactionHashes == null) return null;
+ Block.Header.MerkleRoot ??= MerkleTree.ComputeRoot(TransactionHashes);
+ return Block;
+ }
+
+ public bool Load()
+ {
+ byte[] data = store.TryGet(ConsensusStateKey);
+ if (data is null || data.Length == 0) return false;
+ MemoryReader reader = new(data);
+ try
+ {
+ Deserialize(ref reader);
+ }
+ catch (InvalidOperationException)
+ {
+ return false;
+ }
+ catch (Exception exception)
+ {
+ Utility.Log(nameof(ConsensusContext), LogLevel.Debug, exception.ToString());
+ return false;
+ }
+ return true;
+ }
+
+ public void Reset(byte viewNumber)
+ {
+ if (viewNumber == 0)
+ {
+ Snapshot?.Dispose();
+ Snapshot = neoSystem.GetSnapshot();
+ uint height = NativeContract.Ledger.CurrentIndex(Snapshot);
+ Block = new Block
+ {
+ Header = new Header
+ {
+ PrevHash = NativeContract.Ledger.CurrentHash(Snapshot),
+ Index = height + 1,
+ NextConsensus = Contract.GetBFTAddress(
+ NeoToken.ShouldRefreshCommittee(height + 1, neoSystem.Settings.CommitteeMembersCount) ?
+ NativeContract.NEO.ComputeNextBlockValidators(Snapshot, neoSystem.Settings) :
+ NativeContract.NEO.GetNextBlockValidators(Snapshot, neoSystem.Settings.ValidatorsCount))
+ }
+ };
+ var pv = Validators;
+ Validators = NativeContract.NEO.GetNextBlockValidators(Snapshot, neoSystem.Settings.ValidatorsCount);
+ if (_witnessSize == 0 || (pv != null && pv.Length != Validators.Length))
+ {
+ // Compute the expected size of the witness
+ using (ScriptBuilder sb = new())
+ {
+ for (int x = 0; x < M; x++)
+ {
+ sb.EmitPush(new byte[64]);
+ }
+ _witnessSize = new Witness
+ {
+ InvocationScript = sb.ToArray(),
+ VerificationScript = Contract.CreateMultiSigRedeemScript(M, Validators)
+ }.Size;
+ }
+ }
+ MyIndex = -1;
+ ChangeViewPayloads = new ExtensiblePayload[Validators.Length];
+ LastChangeViewPayloads = new ExtensiblePayload[Validators.Length];
+ CommitPayloads = new ExtensiblePayload[Validators.Length];
+ if (ValidatorsChanged || LastSeenMessage is null)
+ {
+ var previous_last_seen_message = LastSeenMessage;
+ LastSeenMessage = new Dictionary();
+ foreach (var validator in Validators)
+ {
+ if (previous_last_seen_message != null && previous_last_seen_message.TryGetValue(validator, out var value))
+ LastSeenMessage[validator] = value;
+ else
+ LastSeenMessage[validator] = height;
+ }
+ }
+ keyPair = null;
+ for (int i = 0; i < Validators.Length; i++)
+ {
+ WalletAccount account = wallet?.GetAccount(Validators[i]);
+ if (account?.HasKey != true) continue;
+ MyIndex = i;
+ keyPair = account.GetKey();
+ break;
+ }
+ cachedMessages = new Dictionary();
+ }
+ else
+ {
+ for (int i = 0; i < LastChangeViewPayloads.Length; i++)
+ if (GetMessage(ChangeViewPayloads[i])?.NewViewNumber >= viewNumber)
+ LastChangeViewPayloads[i] = ChangeViewPayloads[i];
+ else
+ LastChangeViewPayloads[i] = null;
+ }
+ ViewNumber = viewNumber;
+ Block.Header.PrimaryIndex = GetPrimaryIndex(viewNumber);
+ Block.Header.MerkleRoot = null;
+ Block.Header.Timestamp = 0;
+ Block.Header.Nonce = 0;
+ Block.Transactions = null;
+ TransactionHashes = null;
+ PreparationPayloads = new ExtensiblePayload[Validators.Length];
+ if (MyIndex >= 0) LastSeenMessage[Validators[MyIndex]] = Block.Index;
+ }
+
+ public void Save()
+ {
+ store.PutSync(ConsensusStateKey, this.ToArray());
+ }
+
+ public void Deserialize(ref MemoryReader reader)
+ {
+ Reset(0);
+ if (reader.ReadUInt32() != Block.Version) throw new FormatException();
+ if (reader.ReadUInt32() != Block.Index) throw new InvalidOperationException();
+ Block.Header.Timestamp = reader.ReadUInt64();
+ Block.Header.Nonce = reader.ReadUInt64();
+ Block.Header.PrimaryIndex = reader.ReadByte();
+ Block.Header.NextConsensus = reader.ReadSerializable();
+ if (Block.NextConsensus.Equals(UInt160.Zero))
+ Block.Header.NextConsensus = null;
+ ViewNumber = reader.ReadByte();
+ TransactionHashes = reader.ReadSerializableArray(ushort.MaxValue);
+ Transaction[] transactions = reader.ReadSerializableArray(ushort.MaxValue);
+ PreparationPayloads = reader.ReadNullableArray(neoSystem.Settings.ValidatorsCount);
+ CommitPayloads = reader.ReadNullableArray(neoSystem.Settings.ValidatorsCount);
+ ChangeViewPayloads = reader.ReadNullableArray(neoSystem.Settings.ValidatorsCount);
+ LastChangeViewPayloads = reader.ReadNullableArray(neoSystem.Settings.ValidatorsCount);
+ if (TransactionHashes.Length == 0 && !RequestSentOrReceived)
+ TransactionHashes = null;
+ Transactions = transactions.Length == 0 && !RequestSentOrReceived ? null : transactions.ToDictionary(p => p.Hash);
+ VerificationContext = new TransactionVerificationContext();
+ if (Transactions != null)
+ {
+ foreach (Transaction tx in Transactions.Values)
+ VerificationContext.AddTransaction(tx);
+ }
+ }
+
+ public void Serialize(BinaryWriter writer)
+ {
+ writer.Write(Block.Version);
+ writer.Write(Block.Index);
+ writer.Write(Block.Timestamp);
+ writer.Write(Block.Nonce);
+ writer.Write(Block.PrimaryIndex);
+ writer.Write(Block.NextConsensus ?? UInt160.Zero);
+ writer.Write(ViewNumber);
+ writer.Write(TransactionHashes ?? Array.Empty());
+ writer.Write(Transactions?.Values.ToArray() ?? Array.Empty());
+ writer.WriteNullableArray(PreparationPayloads);
+ writer.WriteNullableArray(CommitPayloads);
+ writer.WriteNullableArray(ChangeViewPayloads);
+ writer.WriteNullableArray(LastChangeViewPayloads);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Consensus/ConsensusService.Check.cs b/src/Plugins/DBFTPlugin/Consensus/ConsensusService.Check.cs
new file mode 100644
index 0000000000..3b15bcd8fc
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Consensus/ConsensusService.Check.cs
@@ -0,0 +1,102 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ConsensusService.Check.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Akka.Actor;
+using Neo.IO;
+using Neo.Network.P2P;
+using Neo.Network.P2P.Payloads;
+using System;
+using System.Linq;
+
+namespace Neo.Consensus
+{
+ partial class ConsensusService
+ {
+ private bool CheckPrepareResponse()
+ {
+ if (context.TransactionHashes.Length == context.Transactions.Count)
+ {
+ // if we are the primary for this view, but acting as a backup because we recovered our own
+ // previously sent prepare request, then we don't want to send a prepare response.
+ if (context.IsPrimary || context.WatchOnly) return true;
+
+ // Check maximum block size via Native Contract policy
+ if (context.GetExpectedBlockSize() > dbftSettings.MaxBlockSize)
+ {
+ Log($"Rejected block: {context.Block.Index} The size exceed the policy", LogLevel.Warning);
+ RequestChangeView(ChangeViewReason.BlockRejectedByPolicy);
+ return false;
+ }
+ // Check maximum block system fee via Native Contract policy
+ if (context.GetExpectedBlockSystemFee() > dbftSettings.MaxBlockSystemFee)
+ {
+ Log($"Rejected block: {context.Block.Index} The system fee exceed the policy", LogLevel.Warning);
+ RequestChangeView(ChangeViewReason.BlockRejectedByPolicy);
+ return false;
+ }
+
+ // Timeout extension due to prepare response sent
+ // around 2*15/M=30.0/5 ~ 40% block time (for M=5)
+ ExtendTimerByFactor(2);
+
+ Log($"Sending {nameof(PrepareResponse)}");
+ localNode.Tell(new LocalNode.SendDirectly { Inventory = context.MakePrepareResponse() });
+ CheckPreparations();
+ }
+ return true;
+ }
+
+ private void CheckCommits()
+ {
+ if (context.CommitPayloads.Count(p => context.GetMessage(p)?.ViewNumber == context.ViewNumber) >= context.M && context.TransactionHashes.All(p => context.Transactions.ContainsKey(p)))
+ {
+ block_received_index = context.Block.Index;
+ block_received_time = TimeProvider.Current.UtcNow;
+ Block block = context.CreateBlock();
+ Log($"Sending {nameof(Block)}: height={block.Index} hash={block.Hash} tx={block.Transactions.Length}");
+ blockchain.Tell(block);
+ }
+ }
+
+ private void CheckExpectedView(byte viewNumber)
+ {
+ if (context.ViewNumber >= viewNumber) return;
+ var messages = context.ChangeViewPayloads.Select(p => context.GetMessage(p)).ToArray();
+ // if there are `M` change view payloads with NewViewNumber greater than viewNumber, then, it is safe to move
+ if (messages.Count(p => p != null && p.NewViewNumber >= viewNumber) >= context.M)
+ {
+ if (!context.WatchOnly)
+ {
+ ChangeView message = messages[context.MyIndex];
+ // Communicate the network about my agreement to move to `viewNumber`
+ // if my last change view payload, `message`, has NewViewNumber lower than current view to change
+ if (message is null || message.NewViewNumber < viewNumber)
+ localNode.Tell(new LocalNode.SendDirectly { Inventory = context.MakeChangeView(ChangeViewReason.ChangeAgreement) });
+ }
+ InitializeConsensus(viewNumber);
+ }
+ }
+
+ private void CheckPreparations()
+ {
+ if (context.PreparationPayloads.Count(p => p != null) >= context.M && context.TransactionHashes.All(p => context.Transactions.ContainsKey(p)))
+ {
+ ExtensiblePayload payload = context.MakeCommit();
+ Log($"Sending {nameof(Commit)}");
+ context.Save();
+ localNode.Tell(new LocalNode.SendDirectly { Inventory = payload });
+ // Set timer, so we will resend the commit in case of a networking issue
+ ChangeTimer(TimeSpan.FromMilliseconds(neoSystem.Settings.MillisecondsPerBlock));
+ CheckCommits();
+ }
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Consensus/ConsensusService.OnMessage.cs b/src/Plugins/DBFTPlugin/Consensus/ConsensusService.OnMessage.cs
new file mode 100644
index 0000000000..ecc31f7ba3
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Consensus/ConsensusService.OnMessage.cs
@@ -0,0 +1,317 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ConsensusService.OnMessage.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Akka.Actor;
+using Neo.Cryptography;
+using Neo.IO;
+using Neo.Ledger;
+using Neo.Network.P2P;
+using Neo.Network.P2P.Payloads;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using Neo.Wallets;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Neo.Consensus
+{
+ partial class ConsensusService
+ {
+ private void OnConsensusPayload(ExtensiblePayload payload)
+ {
+ if (context.BlockSent) return;
+ ConsensusMessage message;
+ try
+ {
+ message = context.GetMessage(payload);
+ }
+ catch (Exception ex)
+ {
+ Utility.Log(nameof(ConsensusService), LogLevel.Debug, ex.ToString());
+ return;
+ }
+
+ if (!message.Verify(neoSystem.Settings)) return;
+ if (message.BlockIndex != context.Block.Index)
+ {
+ if (context.Block.Index < message.BlockIndex)
+ {
+ Log($"Chain is behind: expected={message.BlockIndex} current={context.Block.Index - 1}", LogLevel.Warning);
+ }
+ return;
+ }
+ if (message.ValidatorIndex >= context.Validators.Length) return;
+ if (payload.Sender != Contract.CreateSignatureRedeemScript(context.Validators[message.ValidatorIndex]).ToScriptHash()) return;
+ context.LastSeenMessage[context.Validators[message.ValidatorIndex]] = message.BlockIndex;
+ switch (message)
+ {
+ case PrepareRequest request:
+ OnPrepareRequestReceived(payload, request);
+ break;
+ case PrepareResponse response:
+ OnPrepareResponseReceived(payload, response);
+ break;
+ case ChangeView view:
+ OnChangeViewReceived(payload, view);
+ break;
+ case Commit commit:
+ OnCommitReceived(payload, commit);
+ break;
+ case RecoveryRequest request:
+ OnRecoveryRequestReceived(payload, request);
+ break;
+ case RecoveryMessage recovery:
+ OnRecoveryMessageReceived(recovery);
+ break;
+ }
+ }
+
+ private void OnPrepareRequestReceived(ExtensiblePayload payload, PrepareRequest message)
+ {
+ if (context.RequestSentOrReceived || context.NotAcceptingPayloadsDueToViewChanging) return;
+ if (message.ValidatorIndex != context.Block.PrimaryIndex || message.ViewNumber != context.ViewNumber) return;
+ if (message.Version != context.Block.Version || message.PrevHash != context.Block.PrevHash) return;
+ if (message.TransactionHashes.Length > neoSystem.Settings.MaxTransactionsPerBlock) return;
+ Log($"{nameof(OnPrepareRequestReceived)}: height={message.BlockIndex} view={message.ViewNumber} index={message.ValidatorIndex} tx={message.TransactionHashes.Length}");
+ if (message.Timestamp <= context.PrevHeader.Timestamp || message.Timestamp > TimeProvider.Current.UtcNow.AddMilliseconds(8 * neoSystem.Settings.MillisecondsPerBlock).ToTimestampMS())
+ {
+ Log($"Timestamp incorrect: {message.Timestamp}", LogLevel.Warning);
+ return;
+ }
+
+ if (message.TransactionHashes.Any(p => NativeContract.Ledger.ContainsTransaction(context.Snapshot, p)))
+ {
+ Log($"Invalid request: transaction already exists", LogLevel.Warning);
+ return;
+ }
+
+ // Timeout extension: prepare request has been received with success
+ // around 2*15/M=30.0/5 ~ 40% block time (for M=5)
+ ExtendTimerByFactor(2);
+
+ context.Block.Header.Timestamp = message.Timestamp;
+ context.Block.Header.Nonce = message.Nonce;
+ context.TransactionHashes = message.TransactionHashes;
+
+ context.Transactions = new Dictionary();
+ context.VerificationContext = new TransactionVerificationContext();
+ for (int i = 0; i < context.PreparationPayloads.Length; i++)
+ if (context.PreparationPayloads[i] != null)
+ if (!context.GetMessage(context.PreparationPayloads[i]).PreparationHash.Equals(payload.Hash))
+ context.PreparationPayloads[i] = null;
+ context.PreparationPayloads[message.ValidatorIndex] = payload;
+ byte[] hashData = context.EnsureHeader().GetSignData(neoSystem.Settings.Network);
+ for (int i = 0; i < context.CommitPayloads.Length; i++)
+ if (context.GetMessage(context.CommitPayloads[i])?.ViewNumber == context.ViewNumber)
+ if (!Crypto.VerifySignature(hashData, context.GetMessage(context.CommitPayloads[i]).Signature.Span, context.Validators[i]))
+ context.CommitPayloads[i] = null;
+
+ if (context.TransactionHashes.Length == 0)
+ {
+ // There are no tx so we should act like if all the transactions were filled
+ CheckPrepareResponse();
+ return;
+ }
+
+ Dictionary mempoolVerified = neoSystem.MemPool.GetVerifiedTransactions().ToDictionary(p => p.Hash);
+ List unverified = new List();
+ foreach (UInt256 hash in context.TransactionHashes)
+ {
+ if (mempoolVerified.TryGetValue(hash, out Transaction tx))
+ {
+ if (NativeContract.Ledger.ContainsConflictHash(context.Snapshot, hash, tx.Signers.Select(s => s.Account), neoSystem.Settings.MaxTraceableBlocks))
+ {
+ Log($"Invalid request: transaction has on-chain conflict", LogLevel.Warning);
+ return;
+ }
+
+ if (!AddTransaction(tx, false))
+ return;
+ }
+ else
+ {
+ if (neoSystem.MemPool.TryGetValue(hash, out tx))
+ {
+ if (NativeContract.Ledger.ContainsConflictHash(context.Snapshot, hash, tx.Signers.Select(s => s.Account), neoSystem.Settings.MaxTraceableBlocks))
+ {
+ Log($"Invalid request: transaction has on-chain conflict", LogLevel.Warning);
+ return;
+ }
+ unverified.Add(tx);
+ }
+ }
+ }
+ foreach (Transaction tx in unverified)
+ if (!AddTransaction(tx, true))
+ return;
+ if (context.Transactions.Count < context.TransactionHashes.Length)
+ {
+ UInt256[] hashes = context.TransactionHashes.Where(i => !context.Transactions.ContainsKey(i)).ToArray();
+ taskManager.Tell(new TaskManager.RestartTasks
+ {
+ Payload = InvPayload.Create(InventoryType.TX, hashes)
+ });
+ }
+ }
+
+ private void OnPrepareResponseReceived(ExtensiblePayload payload, PrepareResponse message)
+ {
+ if (message.ViewNumber != context.ViewNumber) return;
+ if (context.PreparationPayloads[message.ValidatorIndex] != null || context.NotAcceptingPayloadsDueToViewChanging) return;
+ if (context.PreparationPayloads[context.Block.PrimaryIndex] != null && !message.PreparationHash.Equals(context.PreparationPayloads[context.Block.PrimaryIndex].Hash))
+ return;
+
+ // Timeout extension: prepare response has been received with success
+ // around 2*15/M=30.0/5 ~ 40% block time (for M=5)
+ ExtendTimerByFactor(2);
+
+ Log($"{nameof(OnPrepareResponseReceived)}: height={message.BlockIndex} view={message.ViewNumber} index={message.ValidatorIndex}");
+ context.PreparationPayloads[message.ValidatorIndex] = payload;
+ if (context.WatchOnly || context.CommitSent) return;
+ if (context.RequestSentOrReceived)
+ CheckPreparations();
+ }
+
+ private void OnChangeViewReceived(ExtensiblePayload payload, ChangeView message)
+ {
+ if (message.NewViewNumber <= context.ViewNumber)
+ OnRecoveryRequestReceived(payload, message);
+
+ if (context.CommitSent) return;
+
+ var expectedView = context.GetMessage(context.ChangeViewPayloads[message.ValidatorIndex])?.NewViewNumber ?? 0;
+ if (message.NewViewNumber <= expectedView)
+ return;
+
+ Log($"{nameof(OnChangeViewReceived)}: height={message.BlockIndex} view={message.ViewNumber} index={message.ValidatorIndex} nv={message.NewViewNumber} reason={message.Reason}");
+ context.ChangeViewPayloads[message.ValidatorIndex] = payload;
+ CheckExpectedView(message.NewViewNumber);
+ }
+
+ private void OnCommitReceived(ExtensiblePayload payload, Commit commit)
+ {
+ ref ExtensiblePayload existingCommitPayload = ref context.CommitPayloads[commit.ValidatorIndex];
+ if (existingCommitPayload != null)
+ {
+ if (existingCommitPayload.Hash != payload.Hash)
+ Log($"Rejected {nameof(Commit)}: height={commit.BlockIndex} index={commit.ValidatorIndex} view={commit.ViewNumber} existingView={context.GetMessage(existingCommitPayload).ViewNumber}", LogLevel.Warning);
+ return;
+ }
+
+ if (commit.ViewNumber == context.ViewNumber)
+ {
+ // Timeout extension: commit has been received with success
+ // around 4*15s/M=60.0s/5=12.0s ~ 80% block time (for M=5)
+ ExtendTimerByFactor(4);
+
+ Log($"{nameof(OnCommitReceived)}: height={commit.BlockIndex} view={commit.ViewNumber} index={commit.ValidatorIndex} nc={context.CountCommitted} nf={context.CountFailed}");
+
+ byte[] hashData = context.EnsureHeader()?.GetSignData(neoSystem.Settings.Network);
+ if (hashData == null)
+ {
+ existingCommitPayload = payload;
+ }
+ else if (Crypto.VerifySignature(hashData, commit.Signature.Span, context.Validators[commit.ValidatorIndex]))
+ {
+ existingCommitPayload = payload;
+ CheckCommits();
+ }
+ return;
+ }
+ else
+ {
+ // Receiving commit from another view
+ existingCommitPayload = payload;
+ }
+ }
+
+ private void OnRecoveryMessageReceived(RecoveryMessage message)
+ {
+ // isRecovering is always set to false again after OnRecoveryMessageReceived
+ isRecovering = true;
+ int validChangeViews = 0, totalChangeViews = 0, validPrepReq = 0, totalPrepReq = 0;
+ int validPrepResponses = 0, totalPrepResponses = 0, validCommits = 0, totalCommits = 0;
+
+ Log($"{nameof(OnRecoveryMessageReceived)}: height={message.BlockIndex} view={message.ViewNumber} index={message.ValidatorIndex}");
+ try
+ {
+ if (message.ViewNumber > context.ViewNumber)
+ {
+ if (context.CommitSent) return;
+ ExtensiblePayload[] changeViewPayloads = message.GetChangeViewPayloads(context);
+ totalChangeViews = changeViewPayloads.Length;
+ foreach (ExtensiblePayload changeViewPayload in changeViewPayloads)
+ if (ReverifyAndProcessPayload(changeViewPayload)) validChangeViews++;
+ }
+ if (message.ViewNumber == context.ViewNumber && !context.NotAcceptingPayloadsDueToViewChanging && !context.CommitSent)
+ {
+ if (!context.RequestSentOrReceived)
+ {
+ ExtensiblePayload prepareRequestPayload = message.GetPrepareRequestPayload(context);
+ if (prepareRequestPayload != null)
+ {
+ totalPrepReq = 1;
+ if (ReverifyAndProcessPayload(prepareRequestPayload)) validPrepReq++;
+ }
+ }
+ ExtensiblePayload[] prepareResponsePayloads = message.GetPrepareResponsePayloads(context);
+ totalPrepResponses = prepareResponsePayloads.Length;
+ foreach (ExtensiblePayload prepareResponsePayload in prepareResponsePayloads)
+ if (ReverifyAndProcessPayload(prepareResponsePayload)) validPrepResponses++;
+ }
+ if (message.ViewNumber <= context.ViewNumber)
+ {
+ // Ensure we know about all commits from lower view numbers.
+ ExtensiblePayload[] commitPayloads = message.GetCommitPayloadsFromRecoveryMessage(context);
+ totalCommits = commitPayloads.Length;
+ foreach (ExtensiblePayload commitPayload in commitPayloads)
+ if (ReverifyAndProcessPayload(commitPayload)) validCommits++;
+ }
+ }
+ finally
+ {
+ Log($"Recovery finished: (valid/total) ChgView: {validChangeViews}/{totalChangeViews} PrepReq: {validPrepReq}/{totalPrepReq} PrepResp: {validPrepResponses}/{totalPrepResponses} Commits: {validCommits}/{totalCommits}");
+ isRecovering = false;
+ }
+ }
+
+ private void OnRecoveryRequestReceived(ExtensiblePayload payload, ConsensusMessage message)
+ {
+ // We keep track of the payload hashes received in this block, and don't respond with recovery
+ // in response to the same payload that we already responded to previously.
+ // ChangeView messages include a Timestamp when the change view is sent, thus if a node restarts
+ // and issues a change view for the same view, it will have a different hash and will correctly respond
+ // again; however replay attacks of the ChangeView message from arbitrary nodes will not trigger an
+ // additional recovery message response.
+ if (!knownHashes.Add(payload.Hash)) return;
+
+ Log($"{nameof(OnRecoveryRequestReceived)}: height={message.BlockIndex} index={message.ValidatorIndex} view={message.ViewNumber}");
+ if (context.WatchOnly) return;
+ if (!context.CommitSent)
+ {
+ bool shouldSendRecovery = false;
+ int allowedRecoveryNodeCount = context.F + 1;
+ // Limit recoveries to be sent from an upper limit of `f + 1` nodes
+ for (int i = 1; i <= allowedRecoveryNodeCount; i++)
+ {
+ var chosenIndex = (message.ValidatorIndex + i) % context.Validators.Length;
+ if (chosenIndex != context.MyIndex) continue;
+ shouldSendRecovery = true;
+ break;
+ }
+
+ if (!shouldSendRecovery) return;
+ }
+ localNode.Tell(new LocalNode.SendDirectly { Inventory = context.MakeRecoveryMessage() });
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Consensus/ConsensusService.cs b/src/Plugins/DBFTPlugin/Consensus/ConsensusService.cs
new file mode 100644
index 0000000000..8a6d75e8b9
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Consensus/ConsensusService.cs
@@ -0,0 +1,344 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ConsensusService.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Akka.Actor;
+using Neo.IO;
+using Neo.Ledger;
+using Neo.Network.P2P;
+using Neo.Network.P2P.Payloads;
+using Neo.Wallets;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using static Neo.Ledger.Blockchain;
+
+namespace Neo.Consensus
+{
+ partial class ConsensusService : UntypedActor
+ {
+ public class Start { }
+ private class Timer { public uint Height; public byte ViewNumber; }
+
+ private readonly ConsensusContext context;
+ private readonly IActorRef localNode;
+ private readonly IActorRef taskManager;
+ private readonly IActorRef blockchain;
+ private ICancelable timer_token;
+ private DateTime block_received_time;
+ private uint block_received_index;
+ private bool started = false;
+
+ ///
+ /// This will record the information from last scheduled timer
+ ///
+ private DateTime clock_started = TimeProvider.Current.UtcNow;
+ private TimeSpan expected_delay = TimeSpan.Zero;
+
+ ///
+ /// This will be cleared every block (so it will not grow out of control, but is used to prevent repeatedly
+ /// responding to the same message.
+ ///
+ private readonly HashSet knownHashes = new();
+ ///
+ /// This variable is only true during OnRecoveryMessageReceived
+ ///
+ private bool isRecovering = false;
+ private readonly Settings dbftSettings;
+ private readonly NeoSystem neoSystem;
+
+ public ConsensusService(NeoSystem neoSystem, Settings settings, Wallet wallet)
+ : this(neoSystem, settings, new ConsensusContext(neoSystem, settings, wallet)) { }
+
+ internal ConsensusService(NeoSystem neoSystem, Settings settings, ConsensusContext context)
+ {
+ this.neoSystem = neoSystem;
+ localNode = neoSystem.LocalNode;
+ taskManager = neoSystem.TaskManager;
+ blockchain = neoSystem.Blockchain;
+ dbftSettings = settings;
+ this.context = context;
+ Context.System.EventStream.Subscribe(Self, typeof(Blockchain.PersistCompleted));
+ Context.System.EventStream.Subscribe(Self, typeof(Blockchain.RelayResult));
+ }
+
+ private void OnPersistCompleted(Block block)
+ {
+ Log($"Persisted {nameof(Block)}: height={block.Index} hash={block.Hash} tx={block.Transactions.Length} nonce={block.Nonce}");
+ knownHashes.Clear();
+ InitializeConsensus(0);
+ }
+
+ private void InitializeConsensus(byte viewNumber)
+ {
+ context.Reset(viewNumber);
+ if (viewNumber > 0)
+ Log($"View changed: view={viewNumber} primary={context.Validators[context.GetPrimaryIndex((byte)(viewNumber - 1u))]}", LogLevel.Warning);
+ Log($"Initialize: height={context.Block.Index} view={viewNumber} index={context.MyIndex} role={(context.IsPrimary ? "Primary" : context.WatchOnly ? "WatchOnly" : "Backup")}");
+ if (context.WatchOnly) return;
+ if (context.IsPrimary)
+ {
+ if (isRecovering)
+ {
+ ChangeTimer(TimeSpan.FromMilliseconds(neoSystem.Settings.MillisecondsPerBlock << (viewNumber + 1)));
+ }
+ else
+ {
+ TimeSpan span = neoSystem.Settings.TimePerBlock;
+ if (block_received_index + 1 == context.Block.Index)
+ {
+ var diff = TimeProvider.Current.UtcNow - block_received_time;
+ if (diff >= span)
+ span = TimeSpan.Zero;
+ else
+ span -= diff;
+ }
+ ChangeTimer(span);
+ }
+ }
+ else
+ {
+ ChangeTimer(TimeSpan.FromMilliseconds(neoSystem.Settings.MillisecondsPerBlock << (viewNumber + 1)));
+ }
+ }
+
+ protected override void OnReceive(object message)
+ {
+ if (message is Start)
+ {
+ if (started) return;
+ OnStart();
+ }
+ else
+ {
+ if (!started) return;
+ switch (message)
+ {
+ case Timer timer:
+ OnTimer(timer);
+ break;
+ case Transaction transaction:
+ OnTransaction(transaction);
+ break;
+ case Blockchain.PersistCompleted completed:
+ OnPersistCompleted(completed.Block);
+ break;
+ case Blockchain.RelayResult rr:
+ if (rr.Result == VerifyResult.Succeed && rr.Inventory is ExtensiblePayload payload && payload.Category == "dBFT")
+ OnConsensusPayload(payload);
+ break;
+ }
+ }
+ }
+
+ private void OnStart()
+ {
+ Log("OnStart");
+ started = true;
+ if (!dbftSettings.IgnoreRecoveryLogs && context.Load())
+ {
+ if (context.Transactions != null)
+ {
+ blockchain.Ask(new Blockchain.FillMemoryPool
+ {
+ Transactions = context.Transactions.Values
+ }).Wait();
+ }
+ if (context.CommitSent)
+ {
+ CheckPreparations();
+ return;
+ }
+ }
+ InitializeConsensus(context.ViewNumber);
+ // Issue a recovery request on start-up in order to possibly catch up with other nodes
+ if (!context.WatchOnly)
+ RequestRecovery();
+ }
+
+ private void OnTimer(Timer timer)
+ {
+ if (context.WatchOnly || context.BlockSent) return;
+ if (timer.Height != context.Block.Index || timer.ViewNumber != context.ViewNumber) return;
+ if (context.IsPrimary && !context.RequestSentOrReceived)
+ {
+ SendPrepareRequest();
+ }
+ else if ((context.IsPrimary && context.RequestSentOrReceived) || context.IsBackup)
+ {
+ if (context.CommitSent)
+ {
+ // Re-send commit periodically by sending recover message in case of a network issue.
+ Log($"Sending {nameof(RecoveryMessage)} to resend {nameof(Commit)}");
+ localNode.Tell(new LocalNode.SendDirectly { Inventory = context.MakeRecoveryMessage() });
+ ChangeTimer(TimeSpan.FromMilliseconds(neoSystem.Settings.MillisecondsPerBlock << 1));
+ }
+ else
+ {
+ var reason = ChangeViewReason.Timeout;
+
+ if (context.Block != null && context.TransactionHashes?.Length > context.Transactions?.Count)
+ {
+ reason = ChangeViewReason.TxNotFound;
+ }
+
+ RequestChangeView(reason);
+ }
+ }
+ }
+
+ private void SendPrepareRequest()
+ {
+ Log($"Sending {nameof(PrepareRequest)}: height={context.Block.Index} view={context.ViewNumber}");
+ localNode.Tell(new LocalNode.SendDirectly { Inventory = context.MakePrepareRequest() });
+
+ if (context.Validators.Length == 1)
+ CheckPreparations();
+
+ if (context.TransactionHashes.Length > 0)
+ {
+ foreach (InvPayload payload in InvPayload.CreateGroup(InventoryType.TX, context.TransactionHashes))
+ localNode.Tell(Message.Create(MessageCommand.Inv, payload));
+ }
+ ChangeTimer(TimeSpan.FromMilliseconds((neoSystem.Settings.MillisecondsPerBlock << (context.ViewNumber + 1)) - (context.ViewNumber == 0 ? neoSystem.Settings.MillisecondsPerBlock : 0)));
+ }
+
+ private void RequestRecovery()
+ {
+ Log($"Sending {nameof(RecoveryRequest)}: height={context.Block.Index} view={context.ViewNumber} nc={context.CountCommitted} nf={context.CountFailed}");
+ localNode.Tell(new LocalNode.SendDirectly { Inventory = context.MakeRecoveryRequest() });
+ }
+
+ private void RequestChangeView(ChangeViewReason reason)
+ {
+ if (context.WatchOnly) return;
+ // Request for next view is always one view more than the current context.ViewNumber
+ // Nodes will not contribute for changing to a view higher than (context.ViewNumber+1), unless they are recovered
+ // The latter may happen by nodes in higher views with, at least, `M` proofs
+ byte expectedView = context.ViewNumber;
+ expectedView++;
+ ChangeTimer(TimeSpan.FromMilliseconds(neoSystem.Settings.MillisecondsPerBlock << (expectedView + 1)));
+ if ((context.CountCommitted + context.CountFailed) > context.F)
+ {
+ RequestRecovery();
+ }
+ else
+ {
+ Log($"Sending {nameof(ChangeView)}: height={context.Block.Index} view={context.ViewNumber} nv={expectedView} nc={context.CountCommitted} nf={context.CountFailed} reason={reason}");
+ localNode.Tell(new LocalNode.SendDirectly { Inventory = context.MakeChangeView(reason) });
+ CheckExpectedView(expectedView);
+ }
+ }
+
+ private bool ReverifyAndProcessPayload(ExtensiblePayload payload)
+ {
+ RelayResult relayResult = blockchain.Ask(new Blockchain.Reverify { Inventories = new IInventory[] { payload } }).Result;
+ if (relayResult.Result != VerifyResult.Succeed) return false;
+ OnConsensusPayload(payload);
+ return true;
+ }
+
+ private void OnTransaction(Transaction transaction)
+ {
+ if (!context.IsBackup || context.NotAcceptingPayloadsDueToViewChanging || !context.RequestSentOrReceived || context.ResponseSent || context.BlockSent)
+ return;
+ if (context.Transactions.ContainsKey(transaction.Hash)) return;
+ if (!context.TransactionHashes.Contains(transaction.Hash)) return;
+ AddTransaction(transaction, true);
+ }
+
+ private bool AddTransaction(Transaction tx, bool verify)
+ {
+ if (verify)
+ {
+ // At this step we're sure that there's no on-chain transaction that conflicts with
+ // the provided tx because of the previous Blockchain's OnReceive check. Thus, we only
+ // need to check that current context doesn't contain conflicting transactions.
+ VerifyResult result;
+
+ // Firstly, check whether tx has Conlicts attribute with the hash of one of the context's transactions.
+ foreach (var h in tx.GetAttributes().Select(attr => attr.Hash))
+ {
+ if (context.TransactionHashes.Contains(h))
+ {
+ result = VerifyResult.HasConflicts;
+ Log($"Rejected tx: {tx.Hash}, {result}{Environment.NewLine}{tx.ToArray().ToHexString()}", LogLevel.Warning);
+ RequestChangeView(ChangeViewReason.TxInvalid);
+ return false;
+ }
+ }
+ // After that, check whether context's transactions have Conflicts attribute with tx's hash.
+ foreach (var pooledTx in context.Transactions.Values)
+ {
+ if (pooledTx.GetAttributes().Select(attr => attr.Hash).Contains(tx.Hash))
+ {
+ result = VerifyResult.HasConflicts;
+ Log($"Rejected tx: {tx.Hash}, {result}{Environment.NewLine}{tx.ToArray().ToHexString()}", LogLevel.Warning);
+ RequestChangeView(ChangeViewReason.TxInvalid);
+ return false;
+ }
+ }
+
+ // We've ensured that there's no conlicting transactions in the context, thus, can safely provide an empty conflicting list
+ // for futher verification.
+ var conflictingTxs = new List();
+ result = tx.Verify(neoSystem.Settings, context.Snapshot, context.VerificationContext, conflictingTxs);
+ if (result != VerifyResult.Succeed)
+ {
+ Log($"Rejected tx: {tx.Hash}, {result}{Environment.NewLine}{tx.ToArray().ToHexString()}", LogLevel.Warning);
+ RequestChangeView(result == VerifyResult.PolicyFail ? ChangeViewReason.TxRejectedByPolicy : ChangeViewReason.TxInvalid);
+ return false;
+ }
+ }
+ context.Transactions[tx.Hash] = tx;
+ context.VerificationContext.AddTransaction(tx);
+ return CheckPrepareResponse();
+ }
+
+ private void ChangeTimer(TimeSpan delay)
+ {
+ clock_started = TimeProvider.Current.UtcNow;
+ expected_delay = delay;
+ timer_token.CancelIfNotNull();
+ timer_token = Context.System.Scheduler.ScheduleTellOnceCancelable(delay, Self, new Timer
+ {
+ Height = context.Block.Index,
+ ViewNumber = context.ViewNumber
+ }, ActorRefs.NoSender);
+ }
+
+ // this function increases existing timer (never decreases) with a value proportional to `maxDelayInBlockTimes`*`Blockchain.MillisecondsPerBlock`
+ private void ExtendTimerByFactor(int maxDelayInBlockTimes)
+ {
+ TimeSpan nextDelay = expected_delay - (TimeProvider.Current.UtcNow - clock_started) + TimeSpan.FromMilliseconds(maxDelayInBlockTimes * neoSystem.Settings.MillisecondsPerBlock / (double)context.M);
+ if (!context.WatchOnly && !context.ViewChanging && !context.CommitSent && (nextDelay > TimeSpan.Zero))
+ ChangeTimer(nextDelay);
+ }
+
+ protected override void PostStop()
+ {
+ Log("OnStop");
+ started = false;
+ Context.System.EventStream.Unsubscribe(Self);
+ context.Dispose();
+ base.PostStop();
+ }
+
+ public static Props Props(NeoSystem neoSystem, Settings dbftSettings, Wallet wallet)
+ {
+ return Akka.Actor.Props.Create(() => new ConsensusService(neoSystem, dbftSettings, wallet));
+ }
+
+ private static void Log(string message, LogLevel level = LogLevel.Info)
+ {
+ Utility.Log(nameof(ConsensusService), level, message);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/DBFTPlugin.cs b/src/Plugins/DBFTPlugin/DBFTPlugin.cs
new file mode 100644
index 0000000000..7fa29ce0dd
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/DBFTPlugin.cs
@@ -0,0 +1,101 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// DBFTPlugin.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Akka.Actor;
+using Neo.ConsoleService;
+using Neo.Network.P2P;
+using Neo.Network.P2P.Payloads;
+using Neo.Plugins;
+using Neo.Wallets;
+
+namespace Neo.Consensus
+{
+ public class DBFTPlugin : Plugin
+ {
+ private IWalletProvider walletProvider;
+ private IActorRef consensus;
+ private bool started = false;
+ private NeoSystem neoSystem;
+ private Settings settings;
+
+ public override string Description => "Consensus plugin with dBFT algorithm.";
+
+ public DBFTPlugin()
+ {
+ RemoteNode.MessageReceived += RemoteNode_MessageReceived;
+ }
+
+ public DBFTPlugin(Settings settings) : this()
+ {
+ this.settings = settings;
+ }
+
+ public override void Dispose()
+ {
+ RemoteNode.MessageReceived -= RemoteNode_MessageReceived;
+ }
+
+ protected override void Configure()
+ {
+ settings ??= new Settings(GetConfiguration());
+ }
+
+ protected override void OnSystemLoaded(NeoSystem system)
+ {
+ if (system.Settings.Network != settings.Network) return;
+ neoSystem = system;
+ neoSystem.ServiceAdded += NeoSystem_ServiceAdded;
+ }
+
+ private void NeoSystem_ServiceAdded(object sender, object service)
+ {
+ if (service is not IWalletProvider provider) return;
+ walletProvider = provider;
+ neoSystem.ServiceAdded -= NeoSystem_ServiceAdded;
+ if (settings.AutoStart)
+ {
+ walletProvider.WalletChanged += WalletProvider_WalletChanged;
+ }
+ }
+
+ private void WalletProvider_WalletChanged(object sender, Wallet wallet)
+ {
+ walletProvider.WalletChanged -= WalletProvider_WalletChanged;
+ Start(wallet);
+ }
+
+ [ConsoleCommand("start consensus", Category = "Consensus", Description = "Start consensus service (dBFT)")]
+ private void OnStart()
+ {
+ Start(walletProvider.GetWallet());
+ }
+
+ public void Start(Wallet wallet)
+ {
+ if (started) return;
+ started = true;
+ consensus = neoSystem.ActorSystem.ActorOf(ConsensusService.Props(neoSystem, settings, wallet));
+ consensus.Tell(new ConsensusService.Start());
+ }
+
+ private bool RemoteNode_MessageReceived(NeoSystem system, Message message)
+ {
+ if (message.Command == MessageCommand.Transaction)
+ {
+ Transaction tx = (Transaction)message.Payload;
+ if (tx.SystemFee > settings.MaxBlockSystemFee)
+ return false;
+ consensus?.Tell(tx);
+ }
+ return true;
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/DBFTPlugin.csproj b/src/Plugins/DBFTPlugin/DBFTPlugin.csproj
new file mode 100644
index 0000000000..fe681cf2ed
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/DBFTPlugin.csproj
@@ -0,0 +1,13 @@
+
+
+
+ net8.0
+ Neo.Consensus.DBFT
+ Neo.Consensus
+
+
+
+
+
+
+
diff --git a/src/Plugins/DBFTPlugin/Messages/ChangeView.cs b/src/Plugins/DBFTPlugin/Messages/ChangeView.cs
new file mode 100644
index 0000000000..e7be40075f
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/ChangeView.cs
@@ -0,0 +1,56 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ChangeView.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System.IO;
+
+namespace Neo.Consensus
+{
+ public class ChangeView : ConsensusMessage
+ {
+ ///
+ /// NewViewNumber is always set to the current ViewNumber asking changeview + 1
+ ///
+ public byte NewViewNumber => (byte)(ViewNumber + 1);
+
+ ///
+ /// Timestamp of when the ChangeView message was created. This allows receiving nodes to ensure
+ /// they only respond once to a specific ChangeView request (it thus prevents replay of the ChangeView
+ /// message from repeatedly broadcasting RecoveryMessages).
+ ///
+ public ulong Timestamp;
+
+ ///
+ /// Reason
+ ///
+ public ChangeViewReason Reason;
+
+ public override int Size => base.Size +
+ sizeof(ulong) + // Timestamp
+ sizeof(ChangeViewReason); // Reason
+
+ public ChangeView() : base(ConsensusMessageType.ChangeView) { }
+
+ public override void Deserialize(ref MemoryReader reader)
+ {
+ base.Deserialize(ref reader);
+ Timestamp = reader.ReadUInt64();
+ Reason = (ChangeViewReason)reader.ReadByte();
+ }
+
+ public override void Serialize(BinaryWriter writer)
+ {
+ base.Serialize(writer);
+ writer.Write(Timestamp);
+ writer.Write((byte)Reason);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/Commit.cs b/src/Plugins/DBFTPlugin/Messages/Commit.cs
new file mode 100644
index 0000000000..6e8fe93d87
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/Commit.cs
@@ -0,0 +1,38 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Commit.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Consensus
+{
+ public class Commit : ConsensusMessage
+ {
+ public ReadOnlyMemory Signature;
+
+ public override int Size => base.Size + Signature.Length;
+
+ public Commit() : base(ConsensusMessageType.Commit) { }
+
+ public override void Deserialize(ref MemoryReader reader)
+ {
+ base.Deserialize(ref reader);
+ Signature = reader.ReadMemory(64);
+ }
+
+ public override void Serialize(BinaryWriter writer)
+ {
+ base.Serialize(writer);
+ writer.Write(Signature.Span);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/ConsensusMessage.cs b/src/Plugins/DBFTPlugin/Messages/ConsensusMessage.cs
new file mode 100644
index 0000000000..4e136a99e5
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/ConsensusMessage.cs
@@ -0,0 +1,69 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ConsensusMessage.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Consensus
+{
+ public abstract class ConsensusMessage : ISerializable
+ {
+ public readonly ConsensusMessageType Type;
+ public uint BlockIndex;
+ public byte ValidatorIndex;
+ public byte ViewNumber;
+
+ public virtual int Size =>
+ sizeof(ConsensusMessageType) + //Type
+ sizeof(uint) + //BlockIndex
+ sizeof(byte) + //ValidatorIndex
+ sizeof(byte); //ViewNumber
+
+ protected ConsensusMessage(ConsensusMessageType type)
+ {
+ if (!Enum.IsDefined(typeof(ConsensusMessageType), type))
+ throw new ArgumentOutOfRangeException(nameof(type));
+ Type = type;
+ }
+
+ public virtual void Deserialize(ref MemoryReader reader)
+ {
+ if (Type != (ConsensusMessageType)reader.ReadByte())
+ throw new FormatException();
+ BlockIndex = reader.ReadUInt32();
+ ValidatorIndex = reader.ReadByte();
+ ViewNumber = reader.ReadByte();
+ }
+
+ public static ConsensusMessage DeserializeFrom(ReadOnlyMemory data)
+ {
+ ConsensusMessageType type = (ConsensusMessageType)data.Span[0];
+ Type t = typeof(ConsensusMessage);
+ t = t.Assembly.GetType($"{t.Namespace}.{type}", false);
+ if (t is null) throw new FormatException();
+ return (ConsensusMessage)data.AsSerializable(t);
+ }
+
+ public virtual bool Verify(ProtocolSettings protocolSettings)
+ {
+ return ValidatorIndex < protocolSettings.ValidatorsCount;
+ }
+
+ public virtual void Serialize(BinaryWriter writer)
+ {
+ writer.Write((byte)Type);
+ writer.Write(BlockIndex);
+ writer.Write(ValidatorIndex);
+ writer.Write(ViewNumber);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/PrepareRequest.cs b/src/Plugins/DBFTPlugin/Messages/PrepareRequest.cs
new file mode 100644
index 0000000000..2bce609f79
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/PrepareRequest.cs
@@ -0,0 +1,64 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// PrepareRequest.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System;
+using System.IO;
+using System.Linq;
+
+namespace Neo.Consensus
+{
+ public class PrepareRequest : ConsensusMessage
+ {
+ public uint Version;
+ public UInt256 PrevHash;
+ public ulong Timestamp;
+ public ulong Nonce;
+ public UInt256[] TransactionHashes;
+
+ public override int Size => base.Size
+ + sizeof(uint) //Version
+ + UInt256.Length //PrevHash
+ + sizeof(ulong) //Timestamp
+ + sizeof(ulong) // Nonce
+ + TransactionHashes.GetVarSize(); //TransactionHashes
+
+ public PrepareRequest() : base(ConsensusMessageType.PrepareRequest) { }
+
+ public override void Deserialize(ref MemoryReader reader)
+ {
+ base.Deserialize(ref reader);
+ Version = reader.ReadUInt32();
+ PrevHash = reader.ReadSerializable();
+ Timestamp = reader.ReadUInt64();
+ Nonce = reader.ReadUInt64();
+ TransactionHashes = reader.ReadSerializableArray(ushort.MaxValue);
+ if (TransactionHashes.Distinct().Count() != TransactionHashes.Length)
+ throw new FormatException();
+ }
+
+ public override bool Verify(ProtocolSettings protocolSettings)
+ {
+ if (!base.Verify(protocolSettings)) return false;
+ return TransactionHashes.Length <= protocolSettings.MaxTransactionsPerBlock;
+ }
+
+ public override void Serialize(BinaryWriter writer)
+ {
+ base.Serialize(writer);
+ writer.Write(Version);
+ writer.Write(PrevHash);
+ writer.Write(Timestamp);
+ writer.Write(Nonce);
+ writer.Write(TransactionHashes);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/PrepareResponse.cs b/src/Plugins/DBFTPlugin/Messages/PrepareResponse.cs
new file mode 100644
index 0000000000..7510ff99bb
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/PrepareResponse.cs
@@ -0,0 +1,37 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// PrepareResponse.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System.IO;
+
+namespace Neo.Consensus
+{
+ public class PrepareResponse : ConsensusMessage
+ {
+ public UInt256 PreparationHash;
+
+ public override int Size => base.Size + PreparationHash.Size;
+
+ public PrepareResponse() : base(ConsensusMessageType.PrepareResponse) { }
+
+ public override void Deserialize(ref MemoryReader reader)
+ {
+ base.Deserialize(ref reader);
+ PreparationHash = reader.ReadSerializable();
+ }
+
+ public override void Serialize(BinaryWriter writer)
+ {
+ base.Serialize(writer);
+ writer.Write(PreparationHash);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.ChangeViewPayloadCompact.cs b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.ChangeViewPayloadCompact.cs
new file mode 100644
index 0000000000..6a7734e569
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.ChangeViewPayloadCompact.cs
@@ -0,0 +1,50 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RecoveryMessage.ChangeViewPayloadCompact.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Consensus
+{
+ partial class RecoveryMessage
+ {
+ public class ChangeViewPayloadCompact : ISerializable
+ {
+ public byte ValidatorIndex;
+ public byte OriginalViewNumber;
+ public ulong Timestamp;
+ public ReadOnlyMemory InvocationScript;
+
+ int ISerializable.Size =>
+ sizeof(byte) + //ValidatorIndex
+ sizeof(byte) + //OriginalViewNumber
+ sizeof(ulong) + //Timestamp
+ InvocationScript.GetVarSize(); //InvocationScript
+
+ void ISerializable.Deserialize(ref MemoryReader reader)
+ {
+ ValidatorIndex = reader.ReadByte();
+ OriginalViewNumber = reader.ReadByte();
+ Timestamp = reader.ReadUInt64();
+ InvocationScript = reader.ReadVarMemory(1024);
+ }
+
+ void ISerializable.Serialize(BinaryWriter writer)
+ {
+ writer.Write(ValidatorIndex);
+ writer.Write(OriginalViewNumber);
+ writer.Write(Timestamp);
+ writer.WriteVarBytes(InvocationScript.Span);
+ }
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.CommitPayloadCompact.cs b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.CommitPayloadCompact.cs
new file mode 100644
index 0000000000..2dfa16597a
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.CommitPayloadCompact.cs
@@ -0,0 +1,50 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RecoveryMessage.CommitPayloadCompact.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Consensus
+{
+ partial class RecoveryMessage
+ {
+ public class CommitPayloadCompact : ISerializable
+ {
+ public byte ViewNumber;
+ public byte ValidatorIndex;
+ public ReadOnlyMemory Signature;
+ public ReadOnlyMemory InvocationScript;
+
+ int ISerializable.Size =>
+ sizeof(byte) + //ViewNumber
+ sizeof(byte) + //ValidatorIndex
+ Signature.Length + //Signature
+ InvocationScript.GetVarSize(); //InvocationScript
+
+ void ISerializable.Deserialize(ref MemoryReader reader)
+ {
+ ViewNumber = reader.ReadByte();
+ ValidatorIndex = reader.ReadByte();
+ Signature = reader.ReadMemory(64);
+ InvocationScript = reader.ReadVarMemory(1024);
+ }
+
+ void ISerializable.Serialize(BinaryWriter writer)
+ {
+ writer.Write(ViewNumber);
+ writer.Write(ValidatorIndex);
+ writer.Write(Signature.Span);
+ writer.WriteVarBytes(InvocationScript.Span);
+ }
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.PreparationPayloadCompact.cs b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.PreparationPayloadCompact.cs
new file mode 100644
index 0000000000..80b2a48b6f
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.PreparationPayloadCompact.cs
@@ -0,0 +1,42 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RecoveryMessage.PreparationPayloadCompact.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Consensus
+{
+ partial class RecoveryMessage
+ {
+ public class PreparationPayloadCompact : ISerializable
+ {
+ public byte ValidatorIndex;
+ public ReadOnlyMemory InvocationScript;
+
+ int ISerializable.Size =>
+ sizeof(byte) + //ValidatorIndex
+ InvocationScript.GetVarSize(); //InvocationScript
+
+ void ISerializable.Deserialize(ref MemoryReader reader)
+ {
+ ValidatorIndex = reader.ReadByte();
+ InvocationScript = reader.ReadVarMemory(1024);
+ }
+
+ void ISerializable.Serialize(BinaryWriter writer)
+ {
+ writer.Write(ValidatorIndex);
+ writer.WriteVarBytes(InvocationScript.Span);
+ }
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.cs b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.cs
new file mode 100644
index 0000000000..fc688d6a1f
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryMessage.cs
@@ -0,0 +1,131 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RecoveryMessage.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using Neo.Network.P2P.Payloads;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Neo.Consensus
+{
+ public partial class RecoveryMessage : ConsensusMessage
+ {
+ public Dictionary ChangeViewMessages;
+ public PrepareRequest PrepareRequestMessage;
+ /// The PreparationHash in case the PrepareRequest hasn't been received yet.
+ /// This can be null if the PrepareRequest information is present, since it can be derived in that case.
+ public UInt256 PreparationHash;
+ public Dictionary PreparationMessages;
+ public Dictionary CommitMessages;
+
+ public override int Size => base.Size
+ + /* ChangeViewMessages */ ChangeViewMessages?.Values.GetVarSize() ?? 0
+ + /* PrepareRequestMessage */ 1 + PrepareRequestMessage?.Size ?? 0
+ + /* PreparationHash */ PreparationHash?.Size ?? 0
+ + /* PreparationMessages */ PreparationMessages?.Values.GetVarSize() ?? 0
+ + /* CommitMessages */ CommitMessages?.Values.GetVarSize() ?? 0;
+
+ public RecoveryMessage() : base(ConsensusMessageType.RecoveryMessage) { }
+
+ public override void Deserialize(ref MemoryReader reader)
+ {
+ base.Deserialize(ref reader);
+ ChangeViewMessages = reader.ReadSerializableArray(byte.MaxValue).ToDictionary(p => p.ValidatorIndex);
+ if (reader.ReadBoolean())
+ {
+ PrepareRequestMessage = reader.ReadSerializable();
+ }
+ else
+ {
+ int preparationHashSize = UInt256.Zero.Size;
+ if (preparationHashSize == (int)reader.ReadVarInt((ulong)preparationHashSize))
+ PreparationHash = new UInt256(reader.ReadMemory(preparationHashSize).Span);
+ }
+
+ PreparationMessages = reader.ReadSerializableArray(byte.MaxValue).ToDictionary(p => p.ValidatorIndex);
+ CommitMessages = reader.ReadSerializableArray(byte.MaxValue).ToDictionary(p => p.ValidatorIndex);
+ }
+
+ public override bool Verify(ProtocolSettings protocolSettings)
+ {
+ if (!base.Verify(protocolSettings)) return false;
+ return (PrepareRequestMessage is null || PrepareRequestMessage.Verify(protocolSettings))
+ && ChangeViewMessages.Values.All(p => p.ValidatorIndex < protocolSettings.ValidatorsCount)
+ && PreparationMessages.Values.All(p => p.ValidatorIndex < protocolSettings.ValidatorsCount)
+ && CommitMessages.Values.All(p => p.ValidatorIndex < protocolSettings.ValidatorsCount);
+ }
+
+ internal ExtensiblePayload[] GetChangeViewPayloads(ConsensusContext context)
+ {
+ return ChangeViewMessages.Values.Select(p => context.CreatePayload(new ChangeView
+ {
+ BlockIndex = BlockIndex,
+ ValidatorIndex = p.ValidatorIndex,
+ ViewNumber = p.OriginalViewNumber,
+ Timestamp = p.Timestamp
+ }, p.InvocationScript)).ToArray();
+ }
+
+ internal ExtensiblePayload[] GetCommitPayloadsFromRecoveryMessage(ConsensusContext context)
+ {
+ return CommitMessages.Values.Select(p => context.CreatePayload(new Commit
+ {
+ BlockIndex = BlockIndex,
+ ValidatorIndex = p.ValidatorIndex,
+ ViewNumber = p.ViewNumber,
+ Signature = p.Signature
+ }, p.InvocationScript)).ToArray();
+ }
+
+ internal ExtensiblePayload GetPrepareRequestPayload(ConsensusContext context)
+ {
+ if (PrepareRequestMessage == null) return null;
+ if (!PreparationMessages.TryGetValue(context.Block.PrimaryIndex, out PreparationPayloadCompact compact))
+ return null;
+ return context.CreatePayload(PrepareRequestMessage, compact.InvocationScript);
+ }
+
+ internal ExtensiblePayload[] GetPrepareResponsePayloads(ConsensusContext context)
+ {
+ UInt256 preparationHash = PreparationHash ?? context.PreparationPayloads[context.Block.PrimaryIndex]?.Hash;
+ if (preparationHash is null) return Array.Empty();
+ return PreparationMessages.Values.Where(p => p.ValidatorIndex != context.Block.PrimaryIndex).Select(p => context.CreatePayload(new PrepareResponse
+ {
+ BlockIndex = BlockIndex,
+ ValidatorIndex = p.ValidatorIndex,
+ ViewNumber = ViewNumber,
+ PreparationHash = preparationHash
+ }, p.InvocationScript)).ToArray();
+ }
+
+ public override void Serialize(BinaryWriter writer)
+ {
+ base.Serialize(writer);
+ writer.Write(ChangeViewMessages.Values.ToArray());
+ bool hasPrepareRequestMessage = PrepareRequestMessage != null;
+ writer.Write(hasPrepareRequestMessage);
+ if (hasPrepareRequestMessage)
+ writer.Write(PrepareRequestMessage);
+ else
+ {
+ if (PreparationHash == null)
+ writer.WriteVarInt(0);
+ else
+ writer.WriteVarBytes(PreparationHash.ToArray());
+ }
+
+ writer.Write(PreparationMessages.Values.ToArray());
+ writer.Write(CommitMessages.Values.ToArray());
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryRequest.cs b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryRequest.cs
new file mode 100644
index 0000000000..84cd381add
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Messages/RecoveryMessage/RecoveryRequest.cs
@@ -0,0 +1,43 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RecoveryRequest.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System.IO;
+
+namespace Neo.Consensus
+{
+ public class RecoveryRequest : ConsensusMessage
+ {
+ ///
+ /// Timestamp of when the ChangeView message was created. This allows receiving nodes to ensure
+ /// they only respond once to a specific RecoveryRequest request.
+ /// In this sense, it prevents replay of the RecoveryRequest message from the repeatedly broadcast of Recovery's messages.
+ ///
+ public ulong Timestamp;
+
+ public override int Size => base.Size
+ + sizeof(ulong); //Timestamp
+
+ public RecoveryRequest() : base(ConsensusMessageType.RecoveryRequest) { }
+
+ public override void Deserialize(ref MemoryReader reader)
+ {
+ base.Deserialize(ref reader);
+ Timestamp = reader.ReadUInt64();
+ }
+
+ public override void Serialize(BinaryWriter writer)
+ {
+ base.Serialize(writer);
+ writer.Write(Timestamp);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Settings.cs b/src/Plugins/DBFTPlugin/Settings.cs
new file mode 100644
index 0000000000..d0ecbb63fd
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Settings.cs
@@ -0,0 +1,35 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Settings.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Microsoft.Extensions.Configuration;
+
+namespace Neo.Consensus
+{
+ public class Settings
+ {
+ public string RecoveryLogs { get; }
+ public bool IgnoreRecoveryLogs { get; }
+ public bool AutoStart { get; }
+ public uint Network { get; }
+ public uint MaxBlockSize { get; }
+ public long MaxBlockSystemFee { get; }
+
+ public Settings(IConfigurationSection section)
+ {
+ RecoveryLogs = section.GetValue("RecoveryLogs", "ConsensusState");
+ IgnoreRecoveryLogs = section.GetValue("IgnoreRecoveryLogs", false);
+ AutoStart = section.GetValue("AutoStart", false);
+ Network = section.GetValue("Network", 5195086u);
+ MaxBlockSize = section.GetValue("MaxBlockSize", 262144u);
+ MaxBlockSystemFee = section.GetValue("MaxBlockSystemFee", 150000000000L);
+ }
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Types/ChangeViewReason.cs b/src/Plugins/DBFTPlugin/Types/ChangeViewReason.cs
new file mode 100644
index 0000000000..4c0a3c1100
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Types/ChangeViewReason.cs
@@ -0,0 +1,23 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ChangeViewReason.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+namespace Neo.Consensus
+{
+ public enum ChangeViewReason : byte
+ {
+ Timeout = 0x0,
+ ChangeAgreement = 0x1,
+ TxNotFound = 0x2,
+ TxRejectedByPolicy = 0x3,
+ TxInvalid = 0x4,
+ BlockRejectedByPolicy = 0x5
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/Types/ConsensusMessageType.cs b/src/Plugins/DBFTPlugin/Types/ConsensusMessageType.cs
new file mode 100644
index 0000000000..f325133f08
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/Types/ConsensusMessageType.cs
@@ -0,0 +1,25 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ConsensusMessageType.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+namespace Neo.Consensus
+{
+ public enum ConsensusMessageType : byte
+ {
+ ChangeView = 0x00,
+
+ PrepareRequest = 0x20,
+ PrepareResponse = 0x21,
+ Commit = 0x30,
+
+ RecoveryRequest = 0x40,
+ RecoveryMessage = 0x41,
+ }
+}
diff --git a/src/Plugins/DBFTPlugin/config.json b/src/Plugins/DBFTPlugin/config.json
new file mode 100644
index 0000000000..2e2b710ba3
--- /dev/null
+++ b/src/Plugins/DBFTPlugin/config.json
@@ -0,0 +1,10 @@
+{
+ "PluginConfiguration": {
+ "RecoveryLogs": "ConsensusState",
+ "IgnoreRecoveryLogs": false,
+ "AutoStart": false,
+ "Network": 860833102,
+ "MaxBlockSize": 2097152,
+ "MaxBlockSystemFee": 150000000000
+ }
+}
diff --git a/src/Plugins/Directory.Build.props b/src/Plugins/Directory.Build.props
new file mode 100644
index 0000000000..4eb51eef9b
--- /dev/null
+++ b/src/Plugins/Directory.Build.props
@@ -0,0 +1,21 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PreserveNewest
+ PreserveNewest
+
+
+
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/DB.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/DB.cs
new file mode 100644
index 0000000000..60e0e24e5a
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/DB.cs
@@ -0,0 +1,114 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// DB.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+using System.IO;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public class DB : IDisposable
+ {
+ private IntPtr handle;
+
+ ///
+ /// Return true if haven't got valid handle
+ ///
+ public bool IsDisposed => handle == IntPtr.Zero;
+
+ private DB(IntPtr handle)
+ {
+ this.handle = handle;
+ }
+
+ public void Dispose()
+ {
+ if (handle != IntPtr.Zero)
+ {
+ Native.leveldb_close(handle);
+ handle = IntPtr.Zero;
+ }
+ }
+
+ public void Delete(WriteOptions options, byte[] key)
+ {
+ Native.leveldb_delete(handle, options.handle, key, (UIntPtr)key.Length, out IntPtr error);
+ NativeHelper.CheckError(error);
+ }
+
+ public byte[] Get(ReadOptions options, byte[] key)
+ {
+ IntPtr value = Native.leveldb_get(handle, options.handle, key, (UIntPtr)key.Length, out UIntPtr length, out IntPtr error);
+ try
+ {
+ NativeHelper.CheckError(error);
+ return value.ToByteArray(length);
+ }
+ finally
+ {
+ if (value != IntPtr.Zero) Native.leveldb_free(value);
+ }
+ }
+
+ public bool Contains(ReadOptions options, byte[] key)
+ {
+ IntPtr value = Native.leveldb_get(handle, options.handle, key, (UIntPtr)key.Length, out _, out IntPtr error);
+ NativeHelper.CheckError(error);
+
+ if (value != IntPtr.Zero)
+ {
+ Native.leveldb_free(value);
+ return true;
+ }
+
+ return false;
+ }
+
+ public Snapshot GetSnapshot()
+ {
+ return new Snapshot(handle);
+ }
+
+ public Iterator NewIterator(ReadOptions options)
+ {
+ return new Iterator(Native.leveldb_create_iterator(handle, options.handle));
+ }
+
+ public static DB Open(string name)
+ {
+ return Open(name, Options.Default);
+ }
+
+ public static DB Open(string name, Options options)
+ {
+ IntPtr handle = Native.leveldb_open(options.handle, Path.GetFullPath(name), out IntPtr error);
+ NativeHelper.CheckError(error);
+ return new DB(handle);
+ }
+
+ public void Put(WriteOptions options, byte[] key, byte[] value)
+ {
+ Native.leveldb_put(handle, options.handle, key, (UIntPtr)key.Length, value, (UIntPtr)value.Length, out IntPtr error);
+ NativeHelper.CheckError(error);
+ }
+
+ public static void Repair(string name, Options options)
+ {
+ Native.leveldb_repair_db(options.handle, Path.GetFullPath(name), out IntPtr error);
+ NativeHelper.CheckError(error);
+ }
+
+ public void Write(WriteOptions options, WriteBatch write_batch)
+ {
+ Native.leveldb_write(handle, options.handle, write_batch.handle, out IntPtr error);
+ NativeHelper.CheckError(error);
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/Helper.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Helper.cs
new file mode 100644
index 0000000000..2ac3a0005f
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Helper.cs
@@ -0,0 +1,63 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Helper.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Persistence;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public static class Helper
+ {
+ public static IEnumerable Seek(this DB db, ReadOptions options, byte[] prefix, SeekDirection direction, Func resultSelector)
+ {
+ using Iterator it = db.NewIterator(options);
+ if (direction == SeekDirection.Forward)
+ {
+ for (it.Seek(prefix); it.Valid(); it.Next())
+ yield return resultSelector(it.Key(), it.Value());
+ }
+ else
+ {
+ // SeekForPrev
+
+ it.Seek(prefix);
+ if (!it.Valid())
+ it.SeekToLast();
+ else if (it.Key().AsSpan().SequenceCompareTo(prefix) > 0)
+ it.Prev();
+
+ for (; it.Valid(); it.Prev())
+ yield return resultSelector(it.Key(), it.Value());
+ }
+ }
+
+ public static IEnumerable FindRange(this DB db, ReadOptions options, byte[] startKey, byte[] endKey, Func resultSelector)
+ {
+ using Iterator it = db.NewIterator(options);
+ for (it.Seek(startKey); it.Valid(); it.Next())
+ {
+ byte[] key = it.Key();
+ if (key.AsSpan().SequenceCompareTo(endKey) > 0) break;
+ yield return resultSelector(key, it.Value());
+ }
+ }
+
+ internal static byte[] ToByteArray(this IntPtr data, UIntPtr length)
+ {
+ if (data == IntPtr.Zero) return null;
+ byte[] buffer = new byte[(int)length];
+ Marshal.Copy(data, buffer, 0, (int)length);
+ return buffer;
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/Iterator.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Iterator.cs
new file mode 100644
index 0000000000..6c025380fb
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Iterator.cs
@@ -0,0 +1,86 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Iterator.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public class Iterator : IDisposable
+ {
+ private IntPtr handle;
+
+ internal Iterator(IntPtr handle)
+ {
+ this.handle = handle;
+ }
+
+ private void CheckError()
+ {
+ Native.leveldb_iter_get_error(handle, out IntPtr error);
+ NativeHelper.CheckError(error);
+ }
+
+ public void Dispose()
+ {
+ if (handle != IntPtr.Zero)
+ {
+ Native.leveldb_iter_destroy(handle);
+ handle = IntPtr.Zero;
+ }
+ }
+
+ public byte[] Key()
+ {
+ IntPtr key = Native.leveldb_iter_key(handle, out UIntPtr length);
+ CheckError();
+ return key.ToByteArray(length);
+ }
+
+ public void Next()
+ {
+ Native.leveldb_iter_next(handle);
+ CheckError();
+ }
+
+ public void Prev()
+ {
+ Native.leveldb_iter_prev(handle);
+ CheckError();
+ }
+
+ public void Seek(byte[] target)
+ {
+ Native.leveldb_iter_seek(handle, target, (UIntPtr)target.Length);
+ }
+
+ public void SeekToFirst()
+ {
+ Native.leveldb_iter_seek_to_first(handle);
+ }
+
+ public void SeekToLast()
+ {
+ Native.leveldb_iter_seek_to_last(handle);
+ }
+
+ public bool Valid()
+ {
+ return Native.leveldb_iter_valid(handle);
+ }
+
+ public byte[] Value()
+ {
+ IntPtr value = Native.leveldb_iter_value(handle, out UIntPtr length);
+ CheckError();
+ return value.ToByteArray(length);
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/LevelDBException.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/LevelDBException.cs
new file mode 100644
index 0000000000..c9cca42070
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/LevelDBException.cs
@@ -0,0 +1,23 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// LevelDBException.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System.Data.Common;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public class LevelDBException : DbException
+ {
+ internal LevelDBException(string message)
+ : base(message)
+ {
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/Native.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Native.cs
new file mode 100644
index 0000000000..acf8fa82b9
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Native.cs
@@ -0,0 +1,264 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Native.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public enum CompressionType : byte
+ {
+ kNoCompression = 0x0,
+ kSnappyCompression = 0x1
+ }
+
+ public static class Native
+ {
+ #region Logger
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_logger_create(IntPtr /* Action */ logger);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_logger_destroy(IntPtr /* logger*/ option);
+ #endregion
+
+ #region DB
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_open(IntPtr /* Options*/ options, string name, out IntPtr error);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_close(IntPtr /*DB */ db);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_put(IntPtr /* DB */ db, IntPtr /* WriteOptions*/ options, byte[] key, UIntPtr keylen, byte[] val, UIntPtr vallen, out IntPtr errptr);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_delete(IntPtr /* DB */ db, IntPtr /* WriteOptions*/ options, byte[] key, UIntPtr keylen, out IntPtr errptr);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_write(IntPtr /* DB */ db, IntPtr /* WriteOptions*/ options, IntPtr /* WriteBatch */ batch, out IntPtr errptr);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_get(IntPtr /* DB */ db, IntPtr /* ReadOptions*/ options, byte[] key, UIntPtr keylen, out UIntPtr vallen, out IntPtr errptr);
+
+ //[DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ //static extern void leveldb_approximate_sizes(IntPtr /* DB */ db, int num_ranges, byte[] range_start_key, long range_start_key_len, byte[] range_limit_key, long range_limit_key_len, out long sizes);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_create_iterator(IntPtr /* DB */ db, IntPtr /* ReadOption */ options);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_create_snapshot(IntPtr /* DB */ db);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_release_snapshot(IntPtr /* DB */ db, IntPtr /* SnapShot*/ snapshot);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_property_value(IntPtr /* DB */ db, string propname);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_repair_db(IntPtr /* Options*/ options, string name, out IntPtr error);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_destroy_db(IntPtr /* Options*/ options, string name, out IntPtr error);
+
+ #region extensions
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_free(IntPtr /* void */ ptr);
+
+ #endregion
+
+
+ #endregion
+
+ #region Env
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_create_default_env();
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_env_destroy(IntPtr /*Env*/ cache);
+ #endregion
+
+ #region Iterator
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_iter_destroy(IntPtr /*Iterator*/ iterator);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ [return: MarshalAs(UnmanagedType.U1)]
+ public static extern bool leveldb_iter_valid(IntPtr /*Iterator*/ iterator);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_iter_seek_to_first(IntPtr /*Iterator*/ iterator);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_iter_seek_to_last(IntPtr /*Iterator*/ iterator);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_iter_seek(IntPtr /*Iterator*/ iterator, byte[] key, UIntPtr length);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_iter_next(IntPtr /*Iterator*/ iterator);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_iter_prev(IntPtr /*Iterator*/ iterator);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_iter_key(IntPtr /*Iterator*/ iterator, out UIntPtr length);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_iter_value(IntPtr /*Iterator*/ iterator, out UIntPtr length);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_iter_get_error(IntPtr /*Iterator*/ iterator, out IntPtr error);
+ #endregion
+
+ #region Options
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_options_create();
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_destroy(IntPtr /*Options*/ options);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_create_if_missing(IntPtr /*Options*/ options, [MarshalAs(UnmanagedType.U1)] bool o);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_error_if_exists(IntPtr /*Options*/ options, [MarshalAs(UnmanagedType.U1)] bool o);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_info_log(IntPtr /*Options*/ options, IntPtr /* Logger */ logger);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_paranoid_checks(IntPtr /*Options*/ options, [MarshalAs(UnmanagedType.U1)] bool o);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_env(IntPtr /*Options*/ options, IntPtr /*Env*/ env);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_write_buffer_size(IntPtr /*Options*/ options, UIntPtr size);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_max_open_files(IntPtr /*Options*/ options, int max);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_cache(IntPtr /*Options*/ options, IntPtr /*Cache*/ cache);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_block_size(IntPtr /*Options*/ options, UIntPtr size);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_block_restart_interval(IntPtr /*Options*/ options, int interval);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_compression(IntPtr /*Options*/ options, CompressionType level);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_comparator(IntPtr /*Options*/ options, IntPtr /*Comparator*/ comparer);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_options_set_filter_policy(IntPtr /*Options*/ options, IntPtr /*FilterPolicy*/ policy);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_filterpolicy_create_bloom(int bits_per_key);
+ #endregion
+
+ #region ReadOptions
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_readoptions_create();
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_readoptions_destroy(IntPtr /*ReadOptions*/ options);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_readoptions_set_verify_checksums(IntPtr /*ReadOptions*/ options, [MarshalAs(UnmanagedType.U1)] bool o);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_readoptions_set_fill_cache(IntPtr /*ReadOptions*/ options, [MarshalAs(UnmanagedType.U1)] bool o);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_readoptions_set_snapshot(IntPtr /*ReadOptions*/ options, IntPtr /*SnapShot*/ snapshot);
+ #endregion
+
+ #region WriteBatch
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_writebatch_create();
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_writebatch_destroy(IntPtr /* WriteBatch */ batch);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_writebatch_clear(IntPtr /* WriteBatch */ batch);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_writebatch_put(IntPtr /* WriteBatch */ batch, byte[] key, UIntPtr keylen, byte[] val, UIntPtr vallen);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_writebatch_delete(IntPtr /* WriteBatch */ batch, byte[] key, UIntPtr keylen);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_writebatch_iterate(IntPtr /* WriteBatch */ batch, object state, Action put, Action deleted);
+ #endregion
+
+ #region WriteOptions
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_writeoptions_create();
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_writeoptions_destroy(IntPtr /*WriteOptions*/ options);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_writeoptions_set_sync(IntPtr /*WriteOptions*/ options, [MarshalAs(UnmanagedType.U1)] bool o);
+ #endregion
+
+ #region Cache
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr leveldb_cache_create_lru(int capacity);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_cache_destroy(IntPtr /*Cache*/ cache);
+ #endregion
+
+ #region Comparator
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern IntPtr /* leveldb_comparator_t* */
+ leveldb_comparator_create(
+ IntPtr /* void* */ state,
+ IntPtr /* void (*)(void*) */ destructor,
+ IntPtr
+ /* int (*compare)(void*,
+ const char* a, size_t alen,
+ const char* b, size_t blen) */
+ compare,
+ IntPtr /* const char* (*)(void*) */ name);
+
+ [DllImport("libleveldb", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ public static extern void leveldb_comparator_destroy(IntPtr /* leveldb_comparator_t* */ cmp);
+
+ #endregion
+ }
+
+ internal static class NativeHelper
+ {
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void CheckError(IntPtr error)
+ {
+ if (error != IntPtr.Zero)
+ {
+ string message = Marshal.PtrToStringAnsi(error);
+ Native.leveldb_free(error);
+ throw new LevelDBException(message);
+ }
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/Options.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Options.cs
new file mode 100644
index 0000000000..989987eeed
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Options.cs
@@ -0,0 +1,98 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Options.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public class Options
+ {
+ public static readonly Options Default = new Options();
+ internal readonly IntPtr handle = Native.leveldb_options_create();
+
+ public bool CreateIfMissing
+ {
+ set
+ {
+ Native.leveldb_options_set_create_if_missing(handle, value);
+ }
+ }
+
+ public bool ErrorIfExists
+ {
+ set
+ {
+ Native.leveldb_options_set_error_if_exists(handle, value);
+ }
+ }
+
+ public bool ParanoidChecks
+ {
+ set
+ {
+ Native.leveldb_options_set_paranoid_checks(handle, value);
+ }
+ }
+
+ public int WriteBufferSize
+ {
+ set
+ {
+ Native.leveldb_options_set_write_buffer_size(handle, (UIntPtr)value);
+ }
+ }
+
+ public int MaxOpenFiles
+ {
+ set
+ {
+ Native.leveldb_options_set_max_open_files(handle, value);
+ }
+ }
+
+ public int BlockSize
+ {
+ set
+ {
+ Native.leveldb_options_set_block_size(handle, (UIntPtr)value);
+ }
+ }
+
+ public int BlockRestartInterval
+ {
+ set
+ {
+ Native.leveldb_options_set_block_restart_interval(handle, value);
+ }
+ }
+
+ public CompressionType Compression
+ {
+ set
+ {
+ Native.leveldb_options_set_compression(handle, value);
+ }
+ }
+
+ public IntPtr FilterPolicy
+ {
+ set
+ {
+ Native.leveldb_options_set_filter_policy(handle, value);
+ }
+ }
+
+ ~Options()
+ {
+ Native.leveldb_options_destroy(handle);
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/ReadOptions.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/ReadOptions.cs
new file mode 100644
index 0000000000..727ae9f02a
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/ReadOptions.cs
@@ -0,0 +1,50 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ReadOptions.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public class ReadOptions
+ {
+ public static readonly ReadOptions Default = new ReadOptions();
+ internal readonly IntPtr handle = Native.leveldb_readoptions_create();
+
+ public bool VerifyChecksums
+ {
+ set
+ {
+ Native.leveldb_readoptions_set_verify_checksums(handle, value);
+ }
+ }
+
+ public bool FillCache
+ {
+ set
+ {
+ Native.leveldb_readoptions_set_fill_cache(handle, value);
+ }
+ }
+
+ public Snapshot Snapshot
+ {
+ set
+ {
+ Native.leveldb_readoptions_set_snapshot(handle, value.handle);
+ }
+ }
+
+ ~ReadOptions()
+ {
+ Native.leveldb_readoptions_destroy(handle);
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/Snapshot.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Snapshot.cs
new file mode 100644
index 0000000000..14280fbc8f
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/Snapshot.cs
@@ -0,0 +1,35 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Snapshot.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public class Snapshot : IDisposable
+ {
+ internal IntPtr db, handle;
+
+ internal Snapshot(IntPtr db)
+ {
+ this.db = db;
+ handle = Native.leveldb_create_snapshot(db);
+ }
+
+ public void Dispose()
+ {
+ if (handle != IntPtr.Zero)
+ {
+ Native.leveldb_release_snapshot(db, handle);
+ handle = IntPtr.Zero;
+ }
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/WriteBatch.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/WriteBatch.cs
new file mode 100644
index 0000000000..ad82dad450
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/WriteBatch.cs
@@ -0,0 +1,40 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// WriteBatch.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public class WriteBatch
+ {
+ internal readonly IntPtr handle = Native.leveldb_writebatch_create();
+
+ ~WriteBatch()
+ {
+ Native.leveldb_writebatch_destroy(handle);
+ }
+
+ public void Clear()
+ {
+ Native.leveldb_writebatch_clear(handle);
+ }
+
+ public void Delete(byte[] key)
+ {
+ Native.leveldb_writebatch_delete(handle, key, (UIntPtr)key.Length);
+ }
+
+ public void Put(byte[] key, byte[] value)
+ {
+ Native.leveldb_writebatch_put(handle, key, (UIntPtr)key.Length, value, (UIntPtr)value.Length);
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/IO/Data/LevelDB/WriteOptions.cs b/src/Plugins/LevelDBStore/IO/Data/LevelDB/WriteOptions.cs
new file mode 100644
index 0000000000..48915ba480
--- /dev/null
+++ b/src/Plugins/LevelDBStore/IO/Data/LevelDB/WriteOptions.cs
@@ -0,0 +1,36 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// WriteOptions.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+
+namespace Neo.IO.Data.LevelDB
+{
+ public class WriteOptions
+ {
+ public static readonly WriteOptions Default = new WriteOptions();
+ public static readonly WriteOptions SyncWrite = new WriteOptions { Sync = true };
+
+ internal readonly IntPtr handle = Native.leveldb_writeoptions_create();
+
+ public bool Sync
+ {
+ set
+ {
+ Native.leveldb_writeoptions_set_sync(handle, value);
+ }
+ }
+
+ ~WriteOptions()
+ {
+ Native.leveldb_writeoptions_destroy(handle);
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/LevelDBStore.csproj b/src/Plugins/LevelDBStore/LevelDBStore.csproj
new file mode 100644
index 0000000000..ba82156b18
--- /dev/null
+++ b/src/Plugins/LevelDBStore/LevelDBStore.csproj
@@ -0,0 +1,10 @@
+
+
+
+ net8.0
+ Neo.Plugins.Storage.LevelDBStore
+ Neo.Plugins.Storage
+ true
+
+
+
diff --git a/src/Plugins/LevelDBStore/Plugins/Storage/LevelDBStore.cs b/src/Plugins/LevelDBStore/Plugins/Storage/LevelDBStore.cs
new file mode 100644
index 0000000000..9c676e8a7f
--- /dev/null
+++ b/src/Plugins/LevelDBStore/Plugins/Storage/LevelDBStore.cs
@@ -0,0 +1,35 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// LevelDBStore.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO.Data.LevelDB;
+using Neo.Persistence;
+using System;
+using System.Linq;
+
+namespace Neo.Plugins.Storage
+{
+ public class LevelDBStore : Plugin, IStoreProvider
+ {
+ public override string Description => "Uses LevelDB to store the blockchain data";
+
+ public LevelDBStore()
+ {
+ StoreFactory.RegisterProvider(this);
+ }
+
+ public IStore GetStore(string path)
+ {
+ if (Environment.CommandLine.Split(' ').Any(p => p == "/repair" || p == "--repair"))
+ DB.Repair(path, Options.Default);
+ return new Store(path);
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/Plugins/Storage/Snapshot.cs b/src/Plugins/LevelDBStore/Plugins/Storage/Snapshot.cs
new file mode 100644
index 0000000000..0b0a63b885
--- /dev/null
+++ b/src/Plugins/LevelDBStore/Plugins/Storage/Snapshot.cs
@@ -0,0 +1,69 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Snapshot.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO.Data.LevelDB;
+using Neo.Persistence;
+using System.Collections.Generic;
+using LSnapshot = Neo.IO.Data.LevelDB.Snapshot;
+
+namespace Neo.Plugins.Storage
+{
+ internal class Snapshot : ISnapshot
+ {
+ private readonly DB db;
+ private readonly LSnapshot snapshot;
+ private readonly ReadOptions options;
+ private readonly WriteBatch batch;
+
+ public Snapshot(DB db)
+ {
+ this.db = db;
+ snapshot = db.GetSnapshot();
+ options = new ReadOptions { FillCache = false, Snapshot = snapshot };
+ batch = new WriteBatch();
+ }
+
+ public void Commit()
+ {
+ db.Write(WriteOptions.Default, batch);
+ }
+
+ public void Delete(byte[] key)
+ {
+ batch.Delete(key);
+ }
+
+ public void Dispose()
+ {
+ snapshot.Dispose();
+ }
+
+ public IEnumerable<(byte[] Key, byte[] Value)> Seek(byte[] prefix, SeekDirection direction = SeekDirection.Forward)
+ {
+ return db.Seek(options, prefix, direction, (k, v) => (k, v));
+ }
+
+ public void Put(byte[] key, byte[] value)
+ {
+ batch.Put(key, value);
+ }
+
+ public bool Contains(byte[] key)
+ {
+ return db.Contains(options, key);
+ }
+
+ public byte[] TryGet(byte[] key)
+ {
+ return db.Get(options, key);
+ }
+ }
+}
diff --git a/src/Plugins/LevelDBStore/Plugins/Storage/Store.cs b/src/Plugins/LevelDBStore/Plugins/Storage/Store.cs
new file mode 100644
index 0000000000..27b12a8b64
--- /dev/null
+++ b/src/Plugins/LevelDBStore/Plugins/Storage/Store.cs
@@ -0,0 +1,67 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Store.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO.Data.LevelDB;
+using Neo.Persistence;
+using System.Collections.Generic;
+
+namespace Neo.Plugins.Storage
+{
+ internal class Store : IStore
+ {
+ private readonly DB db;
+
+ public Store(string path)
+ {
+ db = DB.Open(path, new Options { CreateIfMissing = true, FilterPolicy = Native.leveldb_filterpolicy_create_bloom(15) });
+ }
+
+ public void Delete(byte[] key)
+ {
+ db.Delete(WriteOptions.Default, key);
+ }
+
+ public void Dispose()
+ {
+ db.Dispose();
+ }
+
+ public IEnumerable<(byte[], byte[])> Seek(byte[] prefix, SeekDirection direction = SeekDirection.Forward)
+ {
+ return db.Seek(ReadOptions.Default, prefix, direction, (k, v) => (k, v));
+ }
+
+ public ISnapshot GetSnapshot()
+ {
+ return new Snapshot(db);
+ }
+
+ public void Put(byte[] key, byte[] value)
+ {
+ db.Put(WriteOptions.Default, key, value);
+ }
+
+ public void PutSync(byte[] key, byte[] value)
+ {
+ db.Put(WriteOptions.SyncWrite, key, value);
+ }
+
+ public bool Contains(byte[] key)
+ {
+ return db.Contains(ReadOptions.Default, key);
+ }
+
+ public byte[] TryGet(byte[] key)
+ {
+ return db.Get(ReadOptions.Default, key);
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Cache.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Cache.cs
new file mode 100644
index 0000000000..d8baef8529
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Cache.cs
@@ -0,0 +1,126 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Cache.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using Neo.Persistence;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ public class Cache
+ {
+ private enum TrackState : byte
+ {
+ None,
+ Added,
+ Changed,
+ Deleted
+ }
+
+ private class Trackable
+ {
+ public Node Node;
+ public TrackState State;
+ }
+
+ private readonly ISnapshot store;
+ private readonly byte prefix;
+ private readonly Dictionary cache = new Dictionary();
+
+ public Cache(ISnapshot store, byte prefix)
+ {
+ this.store = store;
+ this.prefix = prefix;
+ }
+
+ private byte[] Key(UInt256 hash)
+ {
+ byte[] buffer = new byte[UInt256.Length + 1];
+ using (MemoryStream ms = new MemoryStream(buffer, true))
+ using (BinaryWriter writer = new BinaryWriter(ms))
+ {
+ writer.Write(prefix);
+ hash.Serialize(writer);
+ }
+ return buffer;
+ }
+
+ public Node Resolve(UInt256 hash)
+ {
+ if (cache.TryGetValue(hash, out Trackable t))
+ {
+ return t.Node?.Clone();
+ }
+ var n = store.TryGet(Key(hash))?.AsSerializable();
+ cache.Add(hash, new Trackable
+ {
+ Node = n,
+ State = TrackState.None,
+ });
+ return n?.Clone();
+ }
+
+ public void PutNode(Node np)
+ {
+ var n = Resolve(np.Hash);
+ if (n is null)
+ {
+ np.Reference = 1;
+ cache[np.Hash] = new Trackable
+ {
+ Node = np.Clone(),
+ State = TrackState.Added,
+ };
+ return;
+ }
+ var entry = cache[np.Hash];
+ entry.Node.Reference++;
+ entry.State = TrackState.Changed;
+ }
+
+ public void DeleteNode(UInt256 hash)
+ {
+ var n = Resolve(hash);
+ if (n is null) return;
+ if (1 < n.Reference)
+ {
+ var entry = cache[hash];
+ entry.Node.Reference--;
+ entry.State = TrackState.Changed;
+ return;
+ }
+ cache[hash] = new Trackable
+ {
+ Node = null,
+ State = TrackState.Deleted,
+ };
+ }
+
+ public void Commit()
+ {
+ foreach (var item in cache)
+ {
+ switch (item.Value.State)
+ {
+ case TrackState.Added:
+ case TrackState.Changed:
+ store.Put(Key(item.Key), item.Value.Node.ToArray());
+ break;
+ case TrackState.Deleted:
+ store.Delete(Key(item.Key));
+ break;
+ }
+ }
+ cache.Clear();
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Helper.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Helper.cs
new file mode 100644
index 0000000000..5c93afd659
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Helper.cs
@@ -0,0 +1,28 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Helper.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ public static class Helper
+ {
+ public static int CompareTo(this ReadOnlySpan arr1, ReadOnlySpan arr2)
+ {
+ for (int i = 0; i < arr1.Length && i < arr2.Length; i++)
+ {
+ var r = arr1[i].CompareTo(arr2[i]);
+ if (r != 0) return r;
+ }
+ return arr2.Length < arr1.Length ? 1 : arr2.Length == arr1.Length ? 0 : -1;
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Branch.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Branch.cs
new file mode 100644
index 0000000000..c8ff04dfc6
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Branch.cs
@@ -0,0 +1,69 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Node.Branch.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System.IO;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Node
+ {
+ public const int BranchChildCount = 17;
+ public Node[] Children;
+
+ public static Node NewBranch()
+ {
+ var n = new Node
+ {
+ type = NodeType.BranchNode,
+ Reference = 1,
+ Children = new Node[BranchChildCount],
+ };
+ for (int i = 0; i < BranchChildCount; i++)
+ {
+ n.Children[i] = new Node();
+ }
+ return n;
+ }
+
+ protected int BranchSize
+ {
+ get
+ {
+ int size = 0;
+ for (int i = 0; i < BranchChildCount; i++)
+ {
+ size += Children[i].SizeAsChild;
+ }
+ return size;
+ }
+ }
+
+ private void SerializeBranch(BinaryWriter writer)
+ {
+ for (int i = 0; i < BranchChildCount; i++)
+ {
+ Children[i].SerializeAsChild(writer);
+ }
+ }
+
+ private void DeserializeBranch(ref MemoryReader reader)
+ {
+ Children = new Node[BranchChildCount];
+ for (int i = 0; i < BranchChildCount; i++)
+ {
+ var n = new Node();
+ n.Deserialize(ref reader);
+ Children[i] = n;
+ }
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Extension.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Extension.cs
new file mode 100644
index 0000000000..510db49250
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Extension.cs
@@ -0,0 +1,55 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Node.Extension.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using Neo.SmartContract;
+using System;
+using System.IO;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Node
+ {
+ public const int MaxKeyLength = (ApplicationEngine.MaxStorageKeySize + sizeof(int)) * 2;
+ public ReadOnlyMemory Key;
+ public Node Next;
+
+ public static Node NewExtension(byte[] key, Node next)
+ {
+ if (key is null || next is null) throw new ArgumentNullException(nameof(NewExtension));
+ if (key.Length == 0) throw new InvalidOperationException(nameof(NewExtension));
+ var n = new Node
+ {
+ type = NodeType.ExtensionNode,
+ Key = key,
+ Next = next,
+ Reference = 1,
+ };
+ return n;
+ }
+
+ protected int ExtensionSize => Key.GetVarSize() + Next.SizeAsChild;
+
+ private void SerializeExtension(BinaryWriter writer)
+ {
+ writer.WriteVarBytes(Key.Span);
+ Next.SerializeAsChild(writer);
+ }
+
+ private void DeserializeExtension(ref MemoryReader reader)
+ {
+ Key = reader.ReadVarMemory();
+ var n = new Node();
+ n.Deserialize(ref reader);
+ Next = n;
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Hash.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Hash.cs
new file mode 100644
index 0000000000..e0190dd146
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Hash.cs
@@ -0,0 +1,43 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Node.Hash.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Node
+ {
+ public static Node NewHash(UInt256 hash)
+ {
+ if (hash is null) throw new ArgumentNullException(nameof(NewHash));
+ var n = new Node
+ {
+ type = NodeType.HashNode,
+ hash = hash,
+ };
+ return n;
+ }
+
+ protected int HashSize => hash.Size;
+
+ private void SerializeHash(BinaryWriter writer)
+ {
+ writer.Write(hash);
+ }
+
+ private void DeserializeHash(ref MemoryReader reader)
+ {
+ hash = reader.ReadSerializable();
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Leaf.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Leaf.cs
new file mode 100644
index 0000000000..024a07f8c8
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.Leaf.cs
@@ -0,0 +1,48 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Node.Leaf.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using Neo.SmartContract;
+using System;
+using System.IO;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Node
+ {
+ public const int MaxValueLength = 3 + ApplicationEngine.MaxStorageValueSize + sizeof(bool);
+ public ReadOnlyMemory Value;
+
+ public static Node NewLeaf(byte[] value)
+ {
+ if (value is null) throw new ArgumentNullException(nameof(value));
+ var n = new Node
+ {
+ type = NodeType.LeafNode,
+ Value = value,
+ Reference = 1,
+ };
+ return n;
+ }
+
+ protected int LeafSize => Value.GetVarSize();
+
+ private void SerializeLeaf(BinaryWriter writer)
+ {
+ writer.WriteVarBytes(Value.Span);
+ }
+
+ private void DeserializeLeaf(ref MemoryReader reader)
+ {
+ Value = reader.ReadVarMemory();
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.cs
new file mode 100644
index 0000000000..ef45548645
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Node.cs
@@ -0,0 +1,230 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Node.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ public partial class Node : ISerializable
+ {
+ private NodeType type;
+ private UInt256 hash;
+ public int Reference;
+ public UInt256 Hash => hash ??= new UInt256(Crypto.Hash256(ToArrayWithoutReference()));
+ public NodeType Type => type;
+ public bool IsEmpty => type == NodeType.Empty;
+ public int Size
+ {
+ get
+ {
+ int size = sizeof(NodeType);
+ switch (type)
+ {
+ case NodeType.BranchNode:
+ return size + BranchSize + IO.Helper.GetVarSize(Reference);
+ case NodeType.ExtensionNode:
+ return size + ExtensionSize + IO.Helper.GetVarSize(Reference);
+ case NodeType.LeafNode:
+ return size + LeafSize + IO.Helper.GetVarSize(Reference);
+ case NodeType.HashNode:
+ return size + HashSize;
+ case NodeType.Empty:
+ return size;
+ default:
+ throw new InvalidOperationException($"{nameof(Node)} Cannt get size, unsupport type");
+ };
+ }
+ }
+
+ public Node()
+ {
+ type = NodeType.Empty;
+ }
+
+ public void SetDirty()
+ {
+ hash = null;
+ }
+
+ public int SizeAsChild
+ {
+ get
+ {
+ switch (type)
+ {
+ case NodeType.BranchNode:
+ case NodeType.ExtensionNode:
+ case NodeType.LeafNode:
+ return NewHash(Hash).Size;
+ case NodeType.HashNode:
+ case NodeType.Empty:
+ return Size;
+ default:
+ throw new InvalidOperationException(nameof(Node));
+ }
+ }
+ }
+
+ public void SerializeAsChild(BinaryWriter writer)
+ {
+ switch (type)
+ {
+ case NodeType.BranchNode:
+ case NodeType.ExtensionNode:
+ case NodeType.LeafNode:
+ var n = NewHash(Hash);
+ n.Serialize(writer);
+ break;
+ case NodeType.HashNode:
+ case NodeType.Empty:
+ Serialize(writer);
+ break;
+ default:
+ throw new FormatException(nameof(SerializeAsChild));
+ }
+ }
+
+ private void SerializeWithoutReference(BinaryWriter writer)
+ {
+ writer.Write((byte)type);
+ switch (type)
+ {
+ case NodeType.BranchNode:
+ SerializeBranch(writer);
+ break;
+ case NodeType.ExtensionNode:
+ SerializeExtension(writer);
+ break;
+ case NodeType.LeafNode:
+ SerializeLeaf(writer);
+ break;
+ case NodeType.HashNode:
+ SerializeHash(writer);
+ break;
+ case NodeType.Empty:
+ break;
+ default:
+ throw new FormatException(nameof(SerializeWithoutReference));
+ }
+ }
+
+ public void Serialize(BinaryWriter writer)
+ {
+ SerializeWithoutReference(writer);
+ if (type == NodeType.BranchNode || type == NodeType.ExtensionNode || type == NodeType.LeafNode)
+ writer.WriteVarInt(Reference);
+ }
+
+ public byte[] ToArrayWithoutReference()
+ {
+ using MemoryStream ms = new MemoryStream();
+ using BinaryWriter writer = new BinaryWriter(ms, Utility.StrictUTF8, true);
+
+ SerializeWithoutReference(writer);
+ writer.Flush();
+ return ms.ToArray();
+ }
+
+ public void Deserialize(ref MemoryReader reader)
+ {
+ type = (NodeType)reader.ReadByte();
+ switch (type)
+ {
+ case NodeType.BranchNode:
+ DeserializeBranch(ref reader);
+ Reference = (int)reader.ReadVarInt();
+ break;
+ case NodeType.ExtensionNode:
+ DeserializeExtension(ref reader);
+ Reference = (int)reader.ReadVarInt();
+ break;
+ case NodeType.LeafNode:
+ DeserializeLeaf(ref reader);
+ Reference = (int)reader.ReadVarInt();
+ break;
+ case NodeType.Empty:
+ break;
+ case NodeType.HashNode:
+ DeserializeHash(ref reader);
+ break;
+ default:
+ throw new FormatException(nameof(Deserialize));
+ }
+ }
+
+ private Node CloneAsChild()
+ {
+ switch (type)
+ {
+ case NodeType.BranchNode:
+ case NodeType.ExtensionNode:
+ case NodeType.LeafNode:
+ return new Node
+ {
+ type = NodeType.HashNode,
+ hash = Hash,
+ };
+ case NodeType.HashNode:
+ case NodeType.Empty:
+ return Clone();
+ default:
+ throw new InvalidOperationException(nameof(Clone));
+ }
+ }
+
+ public Node Clone()
+ {
+ switch (type)
+ {
+ case NodeType.BranchNode:
+ var n = new Node
+ {
+ type = type,
+ Reference = Reference,
+ Children = new Node[BranchChildCount],
+ };
+ for (int i = 0; i < BranchChildCount; i++)
+ {
+ n.Children[i] = Children[i].CloneAsChild();
+ }
+ return n;
+ case NodeType.ExtensionNode:
+ return new Node
+ {
+ type = type,
+ Key = Key,
+ Next = Next.CloneAsChild(),
+ Reference = Reference,
+ };
+ case NodeType.LeafNode:
+ return new Node
+ {
+ type = type,
+ Value = Value,
+ Reference = Reference,
+ };
+ case NodeType.HashNode:
+ case NodeType.Empty:
+ return this;
+ default:
+ throw new InvalidOperationException(nameof(Clone));
+ }
+ }
+
+ public void FromReplica(Node n)
+ {
+ MemoryReader reader = new(n.ToArray());
+ Deserialize(ref reader);
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/NodeType.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/NodeType.cs
new file mode 100644
index 0000000000..9c676ff2f7
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/NodeType.cs
@@ -0,0 +1,22 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// NodeType.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+namespace Neo.Cryptography.MPTTrie
+{
+ public enum NodeType : byte
+ {
+ BranchNode = 0x00,
+ ExtensionNode = 0x01,
+ LeafNode = 0x02,
+ HashNode = 0x03,
+ Empty = 0x04
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Delete.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Delete.cs
new file mode 100644
index 0000000000..2041100a14
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Delete.cs
@@ -0,0 +1,136 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Trie.Delete.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+using System.Collections.Generic;
+using static Neo.Helper;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Trie
+ {
+ public bool Delete(byte[] key)
+ {
+ var path = ToNibbles(key);
+ if (path.Length == 0)
+ throw new ArgumentException("could not be empty", nameof(key));
+ if (path.Length > Node.MaxKeyLength)
+ throw new ArgumentException("exceeds limit", nameof(key));
+ return TryDelete(ref root, path);
+ }
+
+ private bool TryDelete(ref Node node, ReadOnlySpan path)
+ {
+ switch (node.Type)
+ {
+ case NodeType.LeafNode:
+ {
+ if (path.IsEmpty)
+ {
+ if (!full) cache.DeleteNode(node.Hash);
+ node = new Node();
+ return true;
+ }
+ return false;
+ }
+ case NodeType.ExtensionNode:
+ {
+ if (path.StartsWith(node.Key.Span))
+ {
+ var oldHash = node.Hash;
+ var result = TryDelete(ref node.Next, path[node.Key.Length..]);
+ if (!result) return false;
+ if (!full) cache.DeleteNode(oldHash);
+ if (node.Next.IsEmpty)
+ {
+ node = node.Next;
+ return true;
+ }
+ if (node.Next.Type == NodeType.ExtensionNode)
+ {
+ if (!full) cache.DeleteNode(node.Next.Hash);
+ node.Key = Concat(node.Key.Span, node.Next.Key.Span);
+ node.Next = node.Next.Next;
+ }
+ node.SetDirty();
+ cache.PutNode(node);
+ return true;
+ }
+ return false;
+ }
+ case NodeType.BranchNode:
+ {
+ bool result;
+ var oldHash = node.Hash;
+ if (path.IsEmpty)
+ {
+ result = TryDelete(ref node.Children[Node.BranchChildCount - 1], path);
+ }
+ else
+ {
+ result = TryDelete(ref node.Children[path[0]], path[1..]);
+ }
+ if (!result) return false;
+ if (!full) cache.DeleteNode(oldHash);
+ List childrenIndexes = new List(Node.BranchChildCount);
+ for (int i = 0; i < Node.BranchChildCount; i++)
+ {
+ if (node.Children[i].IsEmpty) continue;
+ childrenIndexes.Add((byte)i);
+ }
+ if (childrenIndexes.Count > 1)
+ {
+ node.SetDirty();
+ cache.PutNode(node);
+ return true;
+ }
+ var lastChildIndex = childrenIndexes[0];
+ var lastChild = node.Children[lastChildIndex];
+ if (lastChildIndex == Node.BranchChildCount - 1)
+ {
+ node = lastChild;
+ return true;
+ }
+ if (lastChild.Type == NodeType.HashNode)
+ {
+ lastChild = cache.Resolve(lastChild.Hash);
+ if (lastChild is null) throw new InvalidOperationException("Internal error, can't resolve hash");
+ }
+ if (lastChild.Type == NodeType.ExtensionNode)
+ {
+ if (!full) cache.DeleteNode(lastChild.Hash);
+ lastChild.Key = Concat(childrenIndexes.ToArray(), lastChild.Key.Span);
+ lastChild.SetDirty();
+ cache.PutNode(lastChild);
+ node = lastChild;
+ return true;
+ }
+ node = Node.NewExtension(childrenIndexes.ToArray(), lastChild);
+ cache.PutNode(node);
+ return true;
+ }
+ case NodeType.Empty:
+ {
+ return false;
+ }
+ case NodeType.HashNode:
+ {
+ var newNode = cache.Resolve(node.Hash);
+ if (newNode is null) throw new InvalidOperationException("Internal error, can't resolve hash when mpt delete");
+ node = newNode;
+ return TryDelete(ref node, path);
+ }
+ default:
+ return false;
+ }
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Find.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Find.cs
new file mode 100644
index 0000000000..b3922e8ce8
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Find.cs
@@ -0,0 +1,170 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Trie.Find.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using static Neo.Helper;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Trie
+ {
+ private ReadOnlySpan Seek(ref Node node, ReadOnlySpan path, out Node start)
+ {
+ switch (node.Type)
+ {
+ case NodeType.LeafNode:
+ {
+ if (path.IsEmpty)
+ {
+ start = node;
+ return ReadOnlySpan.Empty;
+ }
+ break;
+ }
+ case NodeType.Empty:
+ break;
+ case NodeType.HashNode:
+ {
+ var newNode = cache.Resolve(node.Hash);
+ if (newNode is null) throw new InvalidOperationException("Internal error, can't resolve hash when mpt seek");
+ node = newNode;
+ return Seek(ref node, path, out start);
+ }
+ case NodeType.BranchNode:
+ {
+ if (path.IsEmpty)
+ {
+ start = node;
+ return ReadOnlySpan.Empty;
+ }
+ return Concat(path[..1], Seek(ref node.Children[path[0]], path[1..], out start));
+ }
+ case NodeType.ExtensionNode:
+ {
+ if (path.IsEmpty)
+ {
+ start = node.Next;
+ return node.Key.Span;
+ }
+ if (path.StartsWith(node.Key.Span))
+ {
+ return Concat(node.Key.Span, Seek(ref node.Next, path[node.Key.Length..], out start));
+ }
+ if (node.Key.Span.StartsWith(path))
+ {
+ start = node.Next;
+ return node.Key.Span;
+ }
+ break;
+ }
+ }
+ start = null;
+ return ReadOnlySpan.Empty;
+ }
+
+ public IEnumerable<(ReadOnlyMemory Key, ReadOnlyMemory Value)> Find(ReadOnlySpan prefix, byte[] from = null)
+ {
+ var path = ToNibbles(prefix);
+ int offset = 0;
+ if (from is null) from = Array.Empty();
+ if (0 < from.Length)
+ {
+ if (!from.AsSpan().StartsWith(prefix))
+ throw new InvalidOperationException("invalid from key");
+ from = ToNibbles(from.AsSpan());
+ }
+ if (path.Length > Node.MaxKeyLength || from.Length > Node.MaxKeyLength)
+ throw new ArgumentException("exceeds limit");
+ path = Seek(ref root, path, out Node start).ToArray();
+ if (from.Length > 0)
+ {
+ for (int i = 0; i < from.Length && i < path.Length; i++)
+ {
+ if (path[i] < from[i]) return Enumerable.Empty<(ReadOnlyMemory, ReadOnlyMemory)>();
+ if (path[i] > from[i])
+ {
+ offset = from.Length;
+ break;
+ }
+ }
+ if (offset == 0)
+ {
+ offset = Math.Min(path.Length, from.Length);
+ }
+ }
+ return Travers(start, path, from, offset).Select(p => (new ReadOnlyMemory(FromNibbles(p.Key.Span)), p.Value));
+ }
+
+ private IEnumerable<(ReadOnlyMemory Key, ReadOnlyMemory Value)> Travers(Node node, byte[] path, byte[] from, int offset)
+ {
+ if (node is null) yield break;
+ if (offset < 0) throw new InvalidOperationException("invalid offset");
+ switch (node.Type)
+ {
+ case NodeType.LeafNode:
+ {
+ if (from.Length <= offset && !path.SequenceEqual(from))
+ yield return (path, node.Value);
+ break;
+ }
+ case NodeType.Empty:
+ break;
+ case NodeType.HashNode:
+ {
+ var newNode = cache.Resolve(node.Hash);
+ if (newNode is null) throw new InvalidOperationException("Internal error, can't resolve hash when mpt find");
+ node = newNode;
+ foreach (var item in Travers(node, path, from, offset))
+ yield return item;
+ break;
+ }
+ case NodeType.BranchNode:
+ {
+ if (offset < from.Length)
+ {
+ for (int i = 0; i < Node.BranchChildCount - 1; i++)
+ {
+ if (from[offset] < i)
+ foreach (var item in Travers(node.Children[i], Concat(path, new byte[] { (byte)i }), from, from.Length))
+ yield return item;
+ else if (i == from[offset])
+ foreach (var item in Travers(node.Children[i], Concat(path, new byte[] { (byte)i }), from, offset + 1))
+ yield return item;
+ }
+ }
+ else
+ {
+ foreach (var item in Travers(node.Children[Node.BranchChildCount - 1], path, from, offset))
+ yield return item;
+ for (int i = 0; i < Node.BranchChildCount - 1; i++)
+ {
+ foreach (var item in Travers(node.Children[i], Concat(path, new byte[] { (byte)i }), from, offset))
+ yield return item;
+ }
+ }
+ break;
+ }
+ case NodeType.ExtensionNode:
+ {
+ if (offset < from.Length && from.AsSpan()[offset..].StartsWith(node.Key.Span))
+ foreach (var item in Travers(node.Next, Concat(path, node.Key.Span), from, offset + node.Key.Length))
+ yield return item;
+ else if (from.Length <= offset || 0 < node.Key.Span.CompareTo(from.AsSpan(offset)))
+ foreach (var item in Travers(node.Next, Concat(path, node.Key.Span), from, from.Length))
+ yield return item;
+ break;
+ }
+ }
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Get.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Get.cs
new file mode 100644
index 0000000000..da69407ac3
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Get.cs
@@ -0,0 +1,90 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Trie.Get.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+using System.Collections.Generic;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Trie
+ {
+ public byte[] this[byte[] key]
+ {
+ get
+ {
+ var path = ToNibbles(key);
+ if (path.Length == 0)
+ throw new ArgumentException("could not be empty", nameof(key));
+ if (path.Length > Node.MaxKeyLength)
+ throw new ArgumentException("exceeds limit", nameof(key));
+ var result = TryGet(ref root, path, out var value);
+ return result ? value.ToArray() : throw new KeyNotFoundException();
+ }
+ }
+
+ public bool TryGetValue(byte[] key, out byte[] value)
+ {
+ value = default;
+ var path = ToNibbles(key);
+ if (path.Length == 0)
+ throw new ArgumentException("could not be empty", nameof(key));
+ if (path.Length > Node.MaxKeyLength)
+ throw new ArgumentException("exceeds limit", nameof(key));
+ var result = TryGet(ref root, path, out var val);
+ if (result)
+ value = val.ToArray();
+ return result;
+ }
+
+ private bool TryGet(ref Node node, ReadOnlySpan path, out ReadOnlySpan value)
+ {
+ switch (node.Type)
+ {
+ case NodeType.LeafNode:
+ {
+ if (path.IsEmpty)
+ {
+ value = node.Value.Span;
+ return true;
+ }
+ break;
+ }
+ case NodeType.Empty:
+ break;
+ case NodeType.HashNode:
+ {
+ var newNode = cache.Resolve(node.Hash);
+ if (newNode is null) throw new InvalidOperationException("Internal error, can't resolve hash when mpt get");
+ node = newNode;
+ return TryGet(ref node, path, out value);
+ }
+ case NodeType.BranchNode:
+ {
+ if (path.IsEmpty)
+ {
+ return TryGet(ref node.Children[Node.BranchChildCount - 1], path, out value);
+ }
+ return TryGet(ref node.Children[path[0]], path[1..], out value);
+ }
+ case NodeType.ExtensionNode:
+ {
+ if (path.StartsWith(node.Key.Span))
+ {
+ return TryGet(ref node.Next, path[node.Key.Length..], out value);
+ }
+ break;
+ }
+ }
+ value = default;
+ return false;
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Proof.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Proof.cs
new file mode 100644
index 0000000000..e0925452e3
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Proof.cs
@@ -0,0 +1,95 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Trie.Proof.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using Neo.Persistence;
+using System;
+using System.Collections.Generic;
+using static Neo.Helper;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Trie
+ {
+ public bool TryGetProof(byte[] key, out HashSet proof)
+ {
+ var path = ToNibbles(key);
+ if (path.Length == 0)
+ throw new ArgumentException("could not be empty", nameof(key));
+ if (path.Length > Node.MaxKeyLength)
+ throw new ArgumentException("exceeds limit", nameof(key));
+ proof = new HashSet(ByteArrayEqualityComparer.Default);
+ return GetProof(ref root, path, proof);
+ }
+
+ private bool GetProof(ref Node node, ReadOnlySpan path, HashSet set)
+ {
+ switch (node.Type)
+ {
+ case NodeType.LeafNode:
+ {
+ if (path.IsEmpty)
+ {
+ set.Add(node.ToArrayWithoutReference());
+ return true;
+ }
+ break;
+ }
+ case NodeType.Empty:
+ break;
+ case NodeType.HashNode:
+ {
+ var newNode = cache.Resolve(node.Hash);
+ if (newNode is null) throw new InvalidOperationException("Internal error, can't resolve hash when mpt getproof");
+ node = newNode;
+ return GetProof(ref node, path, set);
+ }
+ case NodeType.BranchNode:
+ {
+ set.Add(node.ToArrayWithoutReference());
+ if (path.IsEmpty)
+ {
+ return GetProof(ref node.Children[Node.BranchChildCount - 1], path, set);
+ }
+ return GetProof(ref node.Children[path[0]], path[1..], set);
+ }
+ case NodeType.ExtensionNode:
+ {
+ if (path.StartsWith(node.Key.Span))
+ {
+ set.Add(node.ToArrayWithoutReference());
+ return GetProof(ref node.Next, path[node.Key.Length..], set);
+ }
+ break;
+ }
+ }
+ return false;
+ }
+
+ private static byte[] Key(byte[] hash)
+ {
+ byte[] buffer = new byte[hash.Length + 1];
+ buffer[0] = Prefix;
+ Buffer.BlockCopy(hash, 0, buffer, 1, hash.Length);
+ return buffer;
+ }
+
+ public static byte[] VerifyProof(UInt256 root, byte[] key, HashSet proof)
+ {
+ using var memoryStore = new MemoryStore();
+ foreach (byte[] data in proof)
+ memoryStore.Put(Key(Crypto.Hash256(data)), Concat(data, new byte[] { 1 }));
+ using ISnapshot snapshot = memoryStore.GetSnapshot();
+ var trie = new Trie(snapshot, root, false);
+ return trie[key];
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Put.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Put.cs
new file mode 100644
index 0000000000..5de6f3fc85
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.Put.cs
@@ -0,0 +1,159 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Trie.Put.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ partial class Trie
+ {
+ private static ReadOnlySpan CommonPrefix(ReadOnlySpan a, ReadOnlySpan b)
+ {
+ var minLen = a.Length <= b.Length ? a.Length : b.Length;
+ int i = 0;
+ if (a.Length != 0 && b.Length != 0)
+ {
+ for (i = 0; i < minLen; i++)
+ {
+ if (a[i] != b[i]) break;
+ }
+ }
+ return a[..i];
+ }
+
+ public void Put(byte[] key, byte[] value)
+ {
+ var path = ToNibbles(key);
+ var val = value;
+ if (path.Length == 0 || path.Length > Node.MaxKeyLength)
+ throw new ArgumentException("invalid", nameof(key));
+ if (val.Length > Node.MaxValueLength)
+ throw new ArgumentException("exceed limit", nameof(value));
+ var n = Node.NewLeaf(val);
+ Put(ref root, path, n);
+ }
+
+ private void Put(ref Node node, ReadOnlySpan path, Node val)
+ {
+ switch (node.Type)
+ {
+ case NodeType.LeafNode:
+ {
+ if (path.IsEmpty)
+ {
+ if (!full) cache.DeleteNode(node.Hash);
+ node = val;
+ cache.PutNode(node);
+ return;
+ }
+ var branch = Node.NewBranch();
+ branch.Children[Node.BranchChildCount - 1] = node;
+ Put(ref branch.Children[path[0]], path[1..], val);
+ cache.PutNode(branch);
+ node = branch;
+ break;
+ }
+ case NodeType.ExtensionNode:
+ {
+ if (path.StartsWith(node.Key.Span))
+ {
+ var oldHash = node.Hash;
+ Put(ref node.Next, path[node.Key.Length..], val);
+ if (!full) cache.DeleteNode(oldHash);
+ node.SetDirty();
+ cache.PutNode(node);
+ return;
+ }
+ if (!full) cache.DeleteNode(node.Hash);
+ var prefix = CommonPrefix(node.Key.Span, path);
+ var pathRemain = path[prefix.Length..];
+ var keyRemain = node.Key.Span[prefix.Length..];
+ var child = Node.NewBranch();
+ Node grandChild = new Node();
+ if (keyRemain.Length == 1)
+ {
+ child.Children[keyRemain[0]] = node.Next;
+ }
+ else
+ {
+ var exNode = Node.NewExtension(keyRemain[1..].ToArray(), node.Next);
+ cache.PutNode(exNode);
+ child.Children[keyRemain[0]] = exNode;
+ }
+ if (pathRemain.IsEmpty)
+ {
+ Put(ref grandChild, pathRemain, val);
+ child.Children[Node.BranchChildCount - 1] = grandChild;
+ }
+ else
+ {
+ Put(ref grandChild, pathRemain[1..], val);
+ child.Children[pathRemain[0]] = grandChild;
+ }
+ cache.PutNode(child);
+ if (prefix.Length > 0)
+ {
+ var exNode = Node.NewExtension(prefix.ToArray(), child);
+ cache.PutNode(exNode);
+ node = exNode;
+ }
+ else
+ {
+ node = child;
+ }
+ break;
+ }
+ case NodeType.BranchNode:
+ {
+ var oldHash = node.Hash;
+ if (path.IsEmpty)
+ {
+ Put(ref node.Children[Node.BranchChildCount - 1], path, val);
+ }
+ else
+ {
+ Put(ref node.Children[path[0]], path[1..], val);
+ }
+ if (!full) cache.DeleteNode(oldHash);
+ node.SetDirty();
+ cache.PutNode(node);
+ break;
+ }
+ case NodeType.Empty:
+ {
+ Node newNode;
+ if (path.IsEmpty)
+ {
+ newNode = val;
+ }
+ else
+ {
+ newNode = Node.NewExtension(path.ToArray(), val);
+ cache.PutNode(newNode);
+ }
+ node = newNode;
+ if (val.Type == NodeType.LeafNode) cache.PutNode(val);
+ break;
+ }
+ case NodeType.HashNode:
+ {
+ Node newNode = cache.Resolve(node.Hash);
+ if (newNode is null) throw new InvalidOperationException("Internal error, can't resolve hash when mpt put");
+ node = newNode;
+ Put(ref node, path, val);
+ break;
+ }
+ default:
+ throw new InvalidOperationException("unsupport node type");
+ }
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.cs b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.cs
new file mode 100644
index 0000000000..19ef1c8b4c
--- /dev/null
+++ b/src/Plugins/MPTTrie/Cryptography/MPTTrie/Trie.cs
@@ -0,0 +1,62 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Trie.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Persistence;
+using System;
+
+namespace Neo.Cryptography.MPTTrie
+{
+ public partial class Trie
+ {
+ private const byte Prefix = 0xf0;
+ private readonly bool full;
+ private readonly ISnapshot store;
+ private Node root;
+ private readonly Cache cache;
+ public Node Root => root;
+
+ public Trie(ISnapshot store, UInt256 root, bool full_state = false)
+ {
+ this.store = store ?? throw new ArgumentNullException(nameof(store));
+ cache = new Cache(store, Prefix);
+ this.root = root is null ? new Node() : Node.NewHash(root);
+ full = full_state;
+ }
+
+ private static byte[] ToNibbles(ReadOnlySpan path)
+ {
+ var result = new byte[path.Length * 2];
+ for (int i = 0; i < path.Length; i++)
+ {
+ result[i * 2] = (byte)(path[i] >> 4);
+ result[i * 2 + 1] = (byte)(path[i] & 0x0F);
+ }
+ return result;
+ }
+
+ private static byte[] FromNibbles(ReadOnlySpan path)
+ {
+ if (path.Length % 2 != 0) throw new FormatException($"MPTTrie.FromNibbles invalid path.");
+ var key = new byte[path.Length / 2];
+ for (int i = 0; i < key.Length; i++)
+ {
+ key[i] = (byte)(path[i * 2] << 4);
+ key[i] |= path[i * 2 + 1];
+ }
+ return key;
+ }
+
+ public void Commit()
+ {
+ cache.Commit();
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/IO/ByteArrayEqualityComparer.cs b/src/Plugins/MPTTrie/IO/ByteArrayEqualityComparer.cs
new file mode 100644
index 0000000000..590306d560
--- /dev/null
+++ b/src/Plugins/MPTTrie/IO/ByteArrayEqualityComparer.cs
@@ -0,0 +1,58 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ByteArrayEqualityComparer.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System.Collections.Generic;
+
+namespace Neo.IO
+{
+ public class ByteArrayEqualityComparer : IEqualityComparer
+ {
+ public static readonly ByteArrayEqualityComparer Default = new ByteArrayEqualityComparer();
+
+ public unsafe bool Equals(byte[] x, byte[] y)
+ {
+ if (ReferenceEquals(x, y)) return true;
+ if (x is null || y is null) return false;
+ int len = x.Length;
+ if (len != y.Length) return false;
+ if (len == 0) return true;
+ fixed (byte* xp = x, yp = y)
+ {
+ long* xlp = (long*)xp, ylp = (long*)yp;
+ for (; len >= 8; len -= 8)
+ {
+ if (*xlp != *ylp) return false;
+ xlp++;
+ ylp++;
+ }
+ byte* xbp = (byte*)xlp, ybp = (byte*)ylp;
+ for (; len > 0; len--)
+ {
+ if (*xbp != *ybp) return false;
+ xbp++;
+ ybp++;
+ }
+ }
+ return true;
+ }
+
+ public int GetHashCode(byte[] obj)
+ {
+ unchecked
+ {
+ int hash = 17;
+ foreach (byte element in obj)
+ hash = hash * 31 + element;
+ return hash;
+ }
+ }
+ }
+}
diff --git a/src/Plugins/MPTTrie/MPTTrie.csproj b/src/Plugins/MPTTrie/MPTTrie.csproj
new file mode 100644
index 0000000000..a2c3377a16
--- /dev/null
+++ b/src/Plugins/MPTTrie/MPTTrie.csproj
@@ -0,0 +1,10 @@
+
+
+
+ net8.0
+ Neo.Cryptography.MPT
+ Neo.Cryptography
+ true
+
+
+
diff --git a/src/Plugins/OracleService/Helper.cs b/src/Plugins/OracleService/Helper.cs
new file mode 100644
index 0000000000..35611e8698
--- /dev/null
+++ b/src/Plugins/OracleService/Helper.cs
@@ -0,0 +1,52 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Helper.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System.Linq;
+using System.Net;
+
+namespace Neo.Plugins
+{
+ static class Helper
+ {
+ public static bool IsInternal(this IPHostEntry entry)
+ {
+ return entry.AddressList.Any(p => IsInternal(p));
+ }
+
+ ///
+ /// ::1 - IPv6 loopback
+ /// 10.0.0.0 - 10.255.255.255 (10/8 prefix)
+ /// 127.0.0.0 - 127.255.255.255 (127/8 prefix)
+ /// 172.16.0.0 - 172.31.255.255 (172.16/12 prefix)
+ /// 192.168.0.0 - 192.168.255.255 (192.168/16 prefix)
+ ///
+ /// Address
+ /// True if it was an internal address
+ public static bool IsInternal(this IPAddress ipAddress)
+ {
+ if (IPAddress.IsLoopback(ipAddress)) return true;
+ if (IPAddress.Broadcast.Equals(ipAddress)) return true;
+ if (IPAddress.Any.Equals(ipAddress)) return true;
+ if (IPAddress.IPv6Any.Equals(ipAddress)) return true;
+ if (IPAddress.IPv6Loopback.Equals(ipAddress)) return true;
+
+ var ip = ipAddress.GetAddressBytes();
+ switch (ip[0])
+ {
+ case 10:
+ case 127: return true;
+ case 172: return ip[1] >= 16 && ip[1] < 32;
+ case 192: return ip[1] == 168;
+ default: return false;
+ }
+ }
+ }
+}
diff --git a/src/Plugins/OracleService/OracleService.cs b/src/Plugins/OracleService/OracleService.cs
new file mode 100644
index 0000000000..bdbbc5869e
--- /dev/null
+++ b/src/Plugins/OracleService/OracleService.cs
@@ -0,0 +1,584 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// OracleService.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Akka.Actor;
+using Akka.Util.Internal;
+using Neo.ConsoleService;
+using Neo.Cryptography;
+using Neo.Cryptography.ECC;
+using Neo.IO;
+using Neo.Json;
+using Neo.Ledger;
+using Neo.Network.P2P;
+using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
+using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
+using Neo.SmartContract.Native;
+using Neo.VM;
+using Neo.Wallets;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Neo.Plugins
+{
+ public class OracleService : Plugin
+ {
+ private const int RefreshIntervalMilliSeconds = 1000 * 60 * 3;
+
+ private static readonly HttpClient httpClient = new()
+ {
+ Timeout = TimeSpan.FromSeconds(5),
+ MaxResponseContentBufferSize = ushort.MaxValue
+ };
+
+ private Wallet wallet;
+ private readonly ConcurrentDictionary pendingQueue = new ConcurrentDictionary();
+ private readonly ConcurrentDictionary finishedCache = new ConcurrentDictionary();
+ private Timer timer;
+ private readonly CancellationTokenSource cancelSource = new CancellationTokenSource();
+ private OracleStatus status = OracleStatus.Unstarted;
+ private IWalletProvider walletProvider;
+ private int counter;
+ private NeoSystem System;
+
+ private readonly Dictionary protocols = new Dictionary();
+
+ public override string Description => "Built-in oracle plugin";
+
+ public OracleService()
+ {
+ Blockchain.Committing += OnCommitting;
+ }
+
+ protected override void Configure()
+ {
+ Settings.Load(GetConfiguration());
+ foreach (var (_, p) in protocols)
+ p.Configure();
+ }
+
+ protected override void OnSystemLoaded(NeoSystem system)
+ {
+ if (system.Settings.Network != Settings.Default.Network) return;
+ System = system;
+ System.ServiceAdded += NeoSystem_ServiceAdded;
+ RpcServerPlugin.RegisterMethods(this, Settings.Default.Network);
+ }
+
+ private void NeoSystem_ServiceAdded(object sender, object service)
+ {
+ if (service is IWalletProvider)
+ {
+ walletProvider = service as IWalletProvider;
+ System.ServiceAdded -= NeoSystem_ServiceAdded;
+ if (Settings.Default.AutoStart)
+ {
+ walletProvider.WalletChanged += WalletProvider_WalletChanged;
+ }
+ }
+ }
+
+ private void WalletProvider_WalletChanged(object sender, Wallet wallet)
+ {
+ walletProvider.WalletChanged -= WalletProvider_WalletChanged;
+ Start(wallet);
+ }
+
+ public override void Dispose()
+ {
+ Blockchain.Committing -= OnCommitting;
+ OnStop();
+ while (status != OracleStatus.Stopped)
+ Thread.Sleep(100);
+ foreach (var p in protocols)
+ p.Value.Dispose();
+ }
+
+ [ConsoleCommand("start oracle", Category = "Oracle", Description = "Start oracle service")]
+ private void OnStart()
+ {
+ Start(walletProvider?.GetWallet());
+ }
+
+ public void Start(Wallet wallet)
+ {
+ if (status == OracleStatus.Running) return;
+
+ if (wallet is null)
+ {
+ ConsoleHelper.Warning("Please open wallet first!");
+ return;
+ }
+ if (!CheckOracleAvaiblable(System.StoreView, out ECPoint[] oracles))
+ {
+ ConsoleHelper.Warning("The oracle service is unavailable");
+ return;
+ }
+ if (!CheckOracleAccount(wallet, oracles))
+ {
+ ConsoleHelper.Warning("There is no oracle account in wallet");
+ return;
+ }
+
+ this.wallet = wallet;
+ protocols["https"] = new OracleHttpsProtocol();
+ protocols["neofs"] = new OracleNeoFSProtocol(wallet, oracles);
+ status = OracleStatus.Running;
+ timer = new Timer(OnTimer, null, RefreshIntervalMilliSeconds, Timeout.Infinite);
+ ConsoleHelper.Info($"Oracle started");
+ ProcessRequestsAsync();
+ }
+
+ [ConsoleCommand("stop oracle", Category = "Oracle", Description = "Stop oracle service")]
+ private void OnStop()
+ {
+ cancelSource.Cancel();
+ if (timer != null)
+ {
+ timer.Dispose();
+ timer = null;
+ }
+ status = OracleStatus.Stopped;
+ }
+
+ [ConsoleCommand("oracle status", Category = "Oracle", Description = "Show oracle status")]
+ private void OnShow()
+ {
+ ConsoleHelper.Info($"Oracle status: ", $"{status}");
+ }
+
+ private void OnCommitting(NeoSystem system, Block block, DataCache snapshot, IReadOnlyList applicationExecutedList)
+ {
+ if (system.Settings.Network != Settings.Default.Network) return;
+
+ if (Settings.Default.AutoStart && status == OracleStatus.Unstarted)
+ {
+ OnStart();
+ }
+ if (status != OracleStatus.Running) return;
+ if (!CheckOracleAvaiblable(snapshot, out ECPoint[] oracles) || !CheckOracleAccount(wallet, oracles))
+ OnStop();
+ }
+
+ private async void OnTimer(object state)
+ {
+ try
+ {
+ List outOfDate = new();
+ List tasks = new();
+ foreach (var (id, task) in pendingQueue)
+ {
+ var span = TimeProvider.Current.UtcNow - task.Timestamp;
+ if (span > Settings.Default.MaxTaskTimeout)
+ {
+ outOfDate.Add(id);
+ continue;
+ }
+
+ if (span > TimeSpan.FromMilliseconds(RefreshIntervalMilliSeconds))
+ {
+ foreach (var account in wallet.GetAccounts())
+ if (task.BackupSigns.TryGetValue(account.GetKey().PublicKey, out byte[] sign))
+ tasks.Add(SendResponseSignatureAsync(id, sign, account.GetKey()));
+ }
+ }
+
+ await Task.WhenAll(tasks);
+
+ foreach (ulong requestId in outOfDate)
+ pendingQueue.TryRemove(requestId, out _);
+ foreach (var (key, value) in finishedCache)
+ if (TimeProvider.Current.UtcNow - value > TimeSpan.FromDays(3))
+ finishedCache.TryRemove(key, out _);
+ }
+ catch (Exception e)
+ {
+ Log(e, LogLevel.Error);
+ }
+ finally
+ {
+ if (!cancelSource.IsCancellationRequested)
+ timer?.Change(RefreshIntervalMilliSeconds, Timeout.Infinite);
+ }
+ }
+
+ [RpcMethod]
+ public JObject SubmitOracleResponse(JArray _params)
+ {
+ status.Equals(OracleStatus.Running).True_Or(RpcError.OracleDisabled);
+ ECPoint oraclePub = ECPoint.DecodePoint(Convert.FromBase64String(_params[0].AsString()), ECCurve.Secp256r1);
+ ulong requestId = Result.Ok_Or(() => (ulong)_params[1].AsNumber(), RpcError.InvalidParams.WithData($"Invalid requestId: {_params[1]}"));
+ byte[] txSign = Result.Ok_Or(() => Convert.FromBase64String(_params[2].AsString()), RpcError.InvalidParams.WithData($"Invalid txSign: {_params[2]}"));
+ byte[] msgSign = Result.Ok_Or(() => Convert.FromBase64String(_params[3].AsString()), RpcError.InvalidParams.WithData($"Invalid msgSign: {_params[3]}"));
+
+ finishedCache.ContainsKey(requestId).False_Or(RpcError.OracleRequestFinished);
+
+ using (var snapshot = System.GetSnapshot())
+ {
+ uint height = NativeContract.Ledger.CurrentIndex(snapshot) + 1;
+ var oracles = NativeContract.RoleManagement.GetDesignatedByRole(snapshot, Role.Oracle, height);
+ oracles.Any(p => p.Equals(oraclePub)).True_Or(RpcErrorFactory.OracleNotDesignatedNode(oraclePub));
+ NativeContract.Oracle.GetRequest(snapshot, requestId).NotNull_Or(RpcError.OracleRequestNotFound);
+ var data = Neo.Helper.Concat(oraclePub.ToArray(), BitConverter.GetBytes(requestId), txSign);
+ Crypto.VerifySignature(data, msgSign, oraclePub).True_Or(RpcErrorFactory.InvalidSignature($"Invalid oracle response transaction signature from '{oraclePub}'."));
+ AddResponseTxSign(snapshot, requestId, oraclePub, txSign);
+ }
+ return new JObject();
+ }
+
+ private static async Task SendContentAsync(Uri url, string content)
+ {
+ try
+ {
+ using HttpResponseMessage response = await httpClient.PostAsync(url, new StringContent(content, Encoding.UTF8, "application/json"));
+ response.EnsureSuccessStatusCode();
+ }
+ catch (Exception e)
+ {
+ Log($"Failed to send the response signature to {url}, as {e.Message}", LogLevel.Warning);
+ }
+ }
+
+ private async Task SendResponseSignatureAsync(ulong requestId, byte[] txSign, KeyPair keyPair)
+ {
+ var message = Neo.Helper.Concat(keyPair.PublicKey.ToArray(), BitConverter.GetBytes(requestId), txSign);
+ var sign = Crypto.Sign(message, keyPair.PrivateKey);
+ var param = "\"" + Convert.ToBase64String(keyPair.PublicKey.ToArray()) + "\", " + requestId + ", \"" + Convert.ToBase64String(txSign) + "\",\"" + Convert.ToBase64String(sign) + "\"";
+ var content = "{\"id\":" + Interlocked.Increment(ref counter) + ",\"jsonrpc\":\"2.0\",\"method\":\"submitoracleresponse\",\"params\":[" + param + "]}";
+
+ var tasks = Settings.Default.Nodes.Select(p => SendContentAsync(p, content));
+ await Task.WhenAll(tasks);
+ }
+
+ private async Task ProcessRequestAsync(DataCache snapshot, OracleRequest req)
+ {
+ Log($"[{req.OriginalTxid}] Process oracle request start:<{req.Url}>");
+
+ uint height = NativeContract.Ledger.CurrentIndex(snapshot) + 1;
+
+ (OracleResponseCode code, string data) = await ProcessUrlAsync(req.Url);
+
+ Log($"[{req.OriginalTxid}] Process oracle request end:<{req.Url}>, responseCode:{code}, response:{data}");
+
+ var oracleNodes = NativeContract.RoleManagement.GetDesignatedByRole(snapshot, Role.Oracle, height);
+ foreach (var (requestId, request) in NativeContract.Oracle.GetRequestsByUrl(snapshot, req.Url))
+ {
+ var result = Array.Empty();
+ if (code == OracleResponseCode.Success)
+ {
+ try
+ {
+ result = Filter(data, request.Filter);
+ }
+ catch (Exception ex)
+ {
+ code = OracleResponseCode.Error;
+ Log($"[{req.OriginalTxid}] Filter '{request.Filter}' error:{ex.Message}");
+ }
+ }
+ var response = new OracleResponse() { Id = requestId, Code = code, Result = result };
+ var responseTx = CreateResponseTx(snapshot, request, response, oracleNodes, System.Settings);
+ var backupTx = CreateResponseTx(snapshot, request, new OracleResponse() { Code = OracleResponseCode.ConsensusUnreachable, Id = requestId, Result = Array.Empty() }, oracleNodes, System.Settings, true);
+
+ Log($"[{req.OriginalTxid}]-({requestId}) Built response tx[[{responseTx.Hash}]], responseCode:{code}, result:{result.ToHexString()}, validUntilBlock:{responseTx.ValidUntilBlock}, backupTx:{backupTx.Hash}-{backupTx.ValidUntilBlock}");
+
+ List tasks = new List();
+ ECPoint[] oraclePublicKeys = NativeContract.RoleManagement.GetDesignatedByRole(snapshot, Role.Oracle, height);
+ foreach (var account in wallet.GetAccounts())
+ {
+ var oraclePub = account.GetKey()?.PublicKey;
+ if (!account.HasKey || account.Lock || !oraclePublicKeys.Contains(oraclePub)) continue;
+
+ var txSign = responseTx.Sign(account.GetKey(), System.Settings.Network);
+ var backTxSign = backupTx.Sign(account.GetKey(), System.Settings.Network);
+ AddResponseTxSign(snapshot, requestId, oraclePub, txSign, responseTx, backupTx, backTxSign);
+ tasks.Add(SendResponseSignatureAsync(requestId, txSign, account.GetKey()));
+
+ Log($"[{request.OriginalTxid}]-[[{responseTx.Hash}]] Send oracle sign data, Oracle node: {oraclePub}, Sign: {txSign.ToHexString()}");
+ }
+ await Task.WhenAll(tasks);
+ }
+ }
+
+ private async void ProcessRequestsAsync()
+ {
+ while (!cancelSource.IsCancellationRequested)
+ {
+ using (var snapshot = System.GetSnapshot())
+ {
+ SyncPendingQueue(snapshot);
+ foreach (var (id, request) in NativeContract.Oracle.GetRequests(snapshot))
+ {
+ if (cancelSource.IsCancellationRequested) break;
+ if (!finishedCache.ContainsKey(id) && (!pendingQueue.TryGetValue(id, out OracleTask task) || task.Tx is null))
+ await ProcessRequestAsync(snapshot, request);
+ }
+ }
+ if (cancelSource.IsCancellationRequested) break;
+ await Task.Delay(500);
+ }
+
+ status = OracleStatus.Stopped;
+ }
+
+
+ private void SyncPendingQueue(DataCache snapshot)
+ {
+ var offChainRequests = NativeContract.Oracle.GetRequests(snapshot).ToDictionary(r => r.Item1, r => r.Item2);
+ var onChainRequests = pendingQueue.Keys.Except(offChainRequests.Keys);
+ foreach (var onChainRequest in onChainRequests)
+ {
+ pendingQueue.TryRemove(onChainRequest, out _);
+ }
+ }
+
+ private async Task<(OracleResponseCode, string)> ProcessUrlAsync(string url)
+ {
+ if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
+ return (OracleResponseCode.Error, $"Invalid url:<{url}>");
+ if (!protocols.TryGetValue(uri.Scheme, out IOracleProtocol protocol))
+ return (OracleResponseCode.ProtocolNotSupported, $"Invalid Protocol:<{url}>");
+
+ using CancellationTokenSource ctsTimeout = new(Settings.Default.MaxOracleTimeout);
+ using CancellationTokenSource ctsLinked = CancellationTokenSource.CreateLinkedTokenSource(cancelSource.Token, ctsTimeout.Token);
+
+ try
+ {
+ return await protocol.ProcessAsync(uri, ctsLinked.Token);
+ }
+ catch (Exception ex)
+ {
+ return (OracleResponseCode.Error, $"Request <{url}> Error:{ex.Message}");
+ }
+ }
+
+ public static Transaction CreateResponseTx(DataCache snapshot, OracleRequest request, OracleResponse response, ECPoint[] oracleNodes, ProtocolSettings settings, bool useCurrentHeight = false)
+ {
+ var requestTx = NativeContract.Ledger.GetTransactionState(snapshot, request.OriginalTxid);
+ var n = oracleNodes.Length;
+ var m = n - (n - 1) / 3;
+ var oracleSignContract = Contract.CreateMultiSigContract(m, oracleNodes);
+ uint height = NativeContract.Ledger.CurrentIndex(snapshot);
+ var validUntilBlock = requestTx.BlockIndex + settings.MaxValidUntilBlockIncrement;
+ while (useCurrentHeight && validUntilBlock <= height)
+ {
+ validUntilBlock += settings.MaxValidUntilBlockIncrement;
+ }
+ var tx = new Transaction()
+ {
+ Version = 0,
+ Nonce = unchecked((uint)response.Id),
+ ValidUntilBlock = validUntilBlock,
+ Signers = new[]
+ {
+ new Signer
+ {
+ Account = NativeContract.Oracle.Hash,
+ Scopes = WitnessScope.None
+ },
+ new Signer
+ {
+ Account = oracleSignContract.ScriptHash,
+ Scopes = WitnessScope.None
+ }
+ },
+ Attributes = new[] { response },
+ Script = OracleResponse.FixedScript,
+ Witnesses = new Witness[2]
+ };
+ Dictionary witnessDict = new Dictionary
+ {
+ [oracleSignContract.ScriptHash] = new Witness
+ {
+ InvocationScript = Array.Empty(),
+ VerificationScript = oracleSignContract.Script,
+ },
+ [NativeContract.Oracle.Hash] = new Witness
+ {
+ InvocationScript = Array.Empty(),
+ VerificationScript = Array.Empty(),
+ }
+ };
+
+ UInt160[] hashes = tx.GetScriptHashesForVerifying(snapshot);
+ tx.Witnesses[0] = witnessDict[hashes[0]];
+ tx.Witnesses[1] = witnessDict[hashes[1]];
+
+ // Calculate network fee
+
+ var oracleContract = NativeContract.ContractManagement.GetContract(snapshot, NativeContract.Oracle.Hash);
+ var engine = ApplicationEngine.Create(TriggerType.Verification, tx, snapshot.CreateSnapshot(), settings: settings);
+ ContractMethodDescriptor md = oracleContract.Manifest.Abi.GetMethod("verify", -1);
+ engine.LoadContract(oracleContract, md, CallFlags.None);
+ if (engine.Execute() != VMState.HALT) return null;
+ tx.NetworkFee += engine.GasConsumed;
+
+ var executionFactor = NativeContract.Policy.GetExecFeeFactor(snapshot);
+ var networkFee = executionFactor * SmartContract.Helper.MultiSignatureContractCost(m, n);
+ tx.NetworkFee += networkFee;
+
+ // Base size for transaction: includes const_header + signers + script + hashes + witnesses, except attributes
+
+ int size_inv = 66 * m;
+ int size = Transaction.HeaderSize + tx.Signers.GetVarSize() + tx.Script.GetVarSize()
+ + IO.Helper.GetVarSize(hashes.Length) + witnessDict[NativeContract.Oracle.Hash].Size
+ + IO.Helper.GetVarSize(size_inv) + size_inv + oracleSignContract.Script.GetVarSize();
+
+ var feePerByte = NativeContract.Policy.GetFeePerByte(snapshot);
+ if (response.Result.Length > OracleResponse.MaxResultSize)
+ {
+ response.Code = OracleResponseCode.ResponseTooLarge;
+ response.Result = Array.Empty();
+ }
+ else if (tx.NetworkFee + (size + tx.Attributes.GetVarSize()) * feePerByte > request.GasForResponse)
+ {
+ response.Code = OracleResponseCode.InsufficientFunds;
+ response.Result = Array.Empty();
+ }
+ size += tx.Attributes.GetVarSize();
+ tx.NetworkFee += size * feePerByte;
+
+ // Calcualte system fee
+
+ tx.SystemFee = request.GasForResponse - tx.NetworkFee;
+
+ return tx;
+ }
+
+ private void AddResponseTxSign(DataCache snapshot, ulong requestId, ECPoint oraclePub, byte[] sign, Transaction responseTx = null, Transaction backupTx = null, byte[] backupSign = null)
+ {
+ var task = pendingQueue.GetOrAdd(requestId, _ => new OracleTask
+ {
+ Id = requestId,
+ Request = NativeContract.Oracle.GetRequest(snapshot, requestId),
+ Signs = new ConcurrentDictionary(),
+ BackupSigns = new ConcurrentDictionary()
+ });
+
+ if (responseTx != null)
+ {
+ task.Tx = responseTx;
+ var data = task.Tx.GetSignData(System.Settings.Network);
+ task.Signs.Where(p => !Crypto.VerifySignature(data, p.Value, p.Key)).ForEach(p => task.Signs.Remove(p.Key, out _));
+ }
+ if (backupTx != null)
+ {
+ task.BackupTx = backupTx;
+ var data = task.BackupTx.GetSignData(System.Settings.Network);
+ task.BackupSigns.Where(p => !Crypto.VerifySignature(data, p.Value, p.Key)).ForEach(p => task.BackupSigns.Remove(p.Key, out _));
+ task.BackupSigns.TryAdd(oraclePub, backupSign);
+ }
+ if (task.Tx == null)
+ {
+ task.Signs.TryAdd(oraclePub, sign);
+ task.BackupSigns.TryAdd(oraclePub, sign);
+ return;
+ }
+
+ if (Crypto.VerifySignature(task.Tx.GetSignData(System.Settings.Network), sign, oraclePub))
+ task.Signs.TryAdd(oraclePub, sign);
+ else if (Crypto.VerifySignature(task.BackupTx.GetSignData(System.Settings.Network), sign, oraclePub))
+ task.BackupSigns.TryAdd(oraclePub, sign);
+ else
+ throw new RpcException(RpcErrorFactory.InvalidSignature($"Invalid oracle response transaction signature from '{oraclePub}'."));
+
+ if (CheckTxSign(snapshot, task.Tx, task.Signs) || CheckTxSign(snapshot, task.BackupTx, task.BackupSigns))
+ {
+ finishedCache.TryAdd(requestId, new DateTime());
+ pendingQueue.TryRemove(requestId, out _);
+ }
+ }
+
+ public static byte[] Filter(string input, string filterArgs)
+ {
+ if (string.IsNullOrEmpty(filterArgs))
+ return Utility.StrictUTF8.GetBytes(input);
+
+ JToken beforeObject = JToken.Parse(input);
+ JArray afterObjects = beforeObject.JsonPath(filterArgs);
+ return afterObjects.ToByteArray(false);
+ }
+
+ private bool CheckTxSign(DataCache snapshot, Transaction tx, ConcurrentDictionary OracleSigns)
+ {
+ uint height = NativeContract.Ledger.CurrentIndex(snapshot) + 1;
+ if (tx.ValidUntilBlock <= height)
+ {
+ return false;
+ }
+ ECPoint[] oraclesNodes = NativeContract.RoleManagement.GetDesignatedByRole(snapshot, Role.Oracle, height);
+ int neededThreshold = oraclesNodes.Length - (oraclesNodes.Length - 1) / 3;
+ if (OracleSigns.Count >= neededThreshold && tx != null)
+ {
+ var contract = Contract.CreateMultiSigContract(neededThreshold, oraclesNodes);
+ ScriptBuilder sb = new ScriptBuilder();
+ foreach (var (_, sign) in OracleSigns.OrderBy(p => p.Key))
+ {
+ sb.EmitPush(sign);
+ if (--neededThreshold == 0) break;
+ }
+ var idx = tx.GetScriptHashesForVerifying(snapshot)[0] == contract.ScriptHash ? 0 : 1;
+ tx.Witnesses[idx].InvocationScript = sb.ToArray();
+
+ Log($"Send response tx: responseTx={tx.Hash}");
+
+ System.Blockchain.Tell(tx);
+ return true;
+ }
+ return false;
+ }
+
+ private static bool CheckOracleAvaiblable(DataCache snapshot, out ECPoint[] oracles)
+ {
+ uint height = NativeContract.Ledger.CurrentIndex(snapshot) + 1;
+ oracles = NativeContract.RoleManagement.GetDesignatedByRole(snapshot, Role.Oracle, height);
+ return oracles.Length > 0;
+ }
+
+ private static bool CheckOracleAccount(Wallet wallet, ECPoint[] oracles)
+ {
+ if (wallet is null) return false;
+ return oracles
+ .Select(p => wallet.GetAccount(p))
+ .Any(p => p is not null && p.HasKey && !p.Lock);
+ }
+
+ private static void Log(string message, LogLevel level = LogLevel.Info)
+ {
+ Utility.Log(nameof(OracleService), level, message);
+ }
+
+ class OracleTask
+ {
+ public ulong Id;
+ public OracleRequest Request;
+ public Transaction Tx;
+ public Transaction BackupTx;
+ public ConcurrentDictionary Signs;
+ public ConcurrentDictionary BackupSigns;
+ public readonly DateTime Timestamp = TimeProvider.Current.UtcNow;
+ }
+
+ enum OracleStatus
+ {
+ Unstarted,
+ Running,
+ Stopped,
+ }
+ }
+}
diff --git a/src/Plugins/OracleService/OracleService.csproj b/src/Plugins/OracleService/OracleService.csproj
new file mode 100644
index 0000000000..a5df44e75c
--- /dev/null
+++ b/src/Plugins/OracleService/OracleService.csproj
@@ -0,0 +1,20 @@
+
+
+
+ net8.0
+ Neo.Plugins.OracleService
+
+
+
+
+
+
+
+
+
+ false
+ runtime
+
+
+
+
\ No newline at end of file
diff --git a/src/Plugins/OracleService/Protocols/IOracleProtocol.cs b/src/Plugins/OracleService/Protocols/IOracleProtocol.cs
new file mode 100644
index 0000000000..3532a69454
--- /dev/null
+++ b/src/Plugins/OracleService/Protocols/IOracleProtocol.cs
@@ -0,0 +1,24 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// IOracleProtocol.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Network.P2P.Payloads;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Neo.Plugins
+{
+ interface IOracleProtocol : IDisposable
+ {
+ void Configure();
+ Task<(OracleResponseCode, string)> ProcessAsync(Uri uri, CancellationToken cancellation);
+ }
+}
diff --git a/src/Plugins/OracleService/Protocols/OracleHttpsProtocol.cs b/src/Plugins/OracleService/Protocols/OracleHttpsProtocol.cs
new file mode 100644
index 0000000000..29d3eedc43
--- /dev/null
+++ b/src/Plugins/OracleService/Protocols/OracleHttpsProtocol.cs
@@ -0,0 +1,115 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// OracleHttpsProtocol.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Network.P2P.Payloads;
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Neo.Plugins
+{
+ class OracleHttpsProtocol : IOracleProtocol
+ {
+ private readonly HttpClient client = new(new HttpClientHandler() { AllowAutoRedirect = false });
+
+ public OracleHttpsProtocol()
+ {
+ CustomAttributeData attribute = Assembly.GetExecutingAssembly().CustomAttributes.First(p => p.AttributeType == typeof(AssemblyInformationalVersionAttribute));
+ string version = (string)attribute.ConstructorArguments[0].Value;
+ client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("NeoOracleService", version));
+ }
+
+ public void Configure()
+ {
+ client.DefaultRequestHeaders.Accept.Clear();
+ foreach (string type in Settings.Default.AllowedContentTypes)
+ client.DefaultRequestHeaders.Accept.ParseAdd(type);
+ client.Timeout = Settings.Default.Https.Timeout;
+ }
+
+ public void Dispose()
+ {
+ client.Dispose();
+ }
+
+ public async Task<(OracleResponseCode, string)> ProcessAsync(Uri uri, CancellationToken cancellation)
+ {
+ Utility.Log(nameof(OracleHttpsProtocol), LogLevel.Debug, $"Request: {uri.AbsoluteUri}");
+
+ HttpResponseMessage message;
+ try
+ {
+ int redirects = 2;
+ do
+ {
+ if (!Settings.Default.AllowPrivateHost)
+ {
+ IPHostEntry entry = await Dns.GetHostEntryAsync(uri.Host, cancellation);
+ if (entry.IsInternal())
+ return (OracleResponseCode.Forbidden, null);
+ }
+ message = await client.GetAsync(uri, HttpCompletionOption.ResponseContentRead, cancellation);
+ if (message.Headers.Location is not null)
+ {
+ uri = message.Headers.Location;
+ message = null;
+ }
+ } while (message == null && redirects-- > 0);
+ }
+ catch
+ {
+ return (OracleResponseCode.Timeout, null);
+ }
+ if (message is null)
+ return (OracleResponseCode.Timeout, null);
+ if (message.StatusCode == HttpStatusCode.NotFound)
+ return (OracleResponseCode.NotFound, null);
+ if (message.StatusCode == HttpStatusCode.Forbidden)
+ return (OracleResponseCode.Forbidden, null);
+ if (!message.IsSuccessStatusCode)
+ return (OracleResponseCode.Error, message.StatusCode.ToString());
+ if (!Settings.Default.AllowedContentTypes.Contains(message.Content.Headers.ContentType.MediaType))
+ return (OracleResponseCode.ContentTypeNotSupported, null);
+ if (message.Content.Headers.ContentLength.HasValue && message.Content.Headers.ContentLength > OracleResponse.MaxResultSize)
+ return (OracleResponseCode.ResponseTooLarge, null);
+
+ byte[] buffer = new byte[OracleResponse.MaxResultSize + 1];
+ var stream = message.Content.ReadAsStream(cancellation);
+ var read = await stream.ReadAsync(buffer, 0, buffer.Length, cancellation);
+
+ if (read > OracleResponse.MaxResultSize)
+ return (OracleResponseCode.ResponseTooLarge, null);
+
+ var encoding = GetEncoding(message.Content.Headers);
+ if (!encoding.Equals(Encoding.UTF8))
+ return (OracleResponseCode.Error, null);
+
+ return (OracleResponseCode.Success, Utility.StrictUTF8.GetString(buffer, 0, read));
+ }
+
+ private static Encoding GetEncoding(HttpContentHeaders headers)
+ {
+ Encoding encoding = null;
+ if ((headers.ContentType != null) && (headers.ContentType.CharSet != null))
+ {
+ encoding = Encoding.GetEncoding(headers.ContentType.CharSet);
+ }
+
+ return encoding ?? Encoding.UTF8;
+ }
+ }
+}
diff --git a/src/Plugins/OracleService/Protocols/OracleNeoFSProtocol.cs b/src/Plugins/OracleService/Protocols/OracleNeoFSProtocol.cs
new file mode 100644
index 0000000000..2bf92fa8f4
--- /dev/null
+++ b/src/Plugins/OracleService/Protocols/OracleNeoFSProtocol.cs
@@ -0,0 +1,155 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// OracleNeoFSProtocol.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Cryptography.ECC;
+using Neo.FileStorage.API.Client;
+using Neo.FileStorage.API.Cryptography;
+using Neo.FileStorage.API.Refs;
+using Neo.Network.P2P.Payloads;
+using Neo.Wallets;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web;
+using Object = Neo.FileStorage.API.Object.Object;
+using Range = Neo.FileStorage.API.Object.Range;
+
+namespace Neo.Plugins
+{
+ class OracleNeoFSProtocol : IOracleProtocol
+ {
+ private readonly System.Security.Cryptography.ECDsa privateKey;
+
+ public OracleNeoFSProtocol(Wallet wallet, ECPoint[] oracles)
+ {
+ byte[] key = oracles.Select(p => wallet.GetAccount(p)).Where(p => p is not null && p.HasKey && !p.Lock).FirstOrDefault().GetKey().PrivateKey;
+ privateKey = key.LoadPrivateKey();
+ }
+
+ public void Configure()
+ {
+ }
+
+ public void Dispose()
+ {
+ privateKey.Dispose();
+ }
+
+ public async Task<(OracleResponseCode, string)> ProcessAsync(Uri uri, CancellationToken cancellation)
+ {
+ Utility.Log(nameof(OracleNeoFSProtocol), LogLevel.Debug, $"Request: {uri.AbsoluteUri}");
+ try
+ {
+ (OracleResponseCode code, string data) = await GetAsync(uri, Settings.Default.NeoFS.EndPoint, cancellation);
+ Utility.Log(nameof(OracleNeoFSProtocol), LogLevel.Debug, $"NeoFS result, code: {code}, data: {data}");
+ return (code, data);
+ }
+ catch (Exception e)
+ {
+ Utility.Log(nameof(OracleNeoFSProtocol), LogLevel.Debug, $"NeoFS result: error,{e.Message}");
+ return (OracleResponseCode.Error, null);
+ }
+ }
+
+
+ ///
+ /// GetAsync returns neofs object from the provided url.
+ /// If Command is not provided, full object is requested.
+ ///
+ /// URI scheme is "neofs:ContainerID/ObjectID/Command/offset|length".
+ /// Client host.
+ /// Cancellation token object.
+ /// Returns neofs object.
+ private async Task<(OracleResponseCode, string)> GetAsync(Uri uri, string host, CancellationToken cancellation)
+ {
+ string[] ps = uri.AbsolutePath.Split("/");
+ if (ps.Length < 2) throw new FormatException("Invalid neofs url");
+ ContainerID containerID = ContainerID.FromString(ps[0]);
+ ObjectID objectID = ObjectID.FromString(ps[1]);
+ Address objectAddr = new()
+ {
+ ContainerId = containerID,
+ ObjectId = objectID
+ };
+ using Client client = new(privateKey, host);
+ var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellation);
+ tokenSource.CancelAfter(Settings.Default.NeoFS.Timeout);
+ if (ps.Length == 2)
+ return GetPayload(client, objectAddr, tokenSource.Token);
+ return ps[2] switch
+ {
+ "range" => await GetRangeAsync(client, objectAddr, ps.Skip(3).ToArray(), tokenSource.Token),
+ "header" => (OracleResponseCode.Success, await GetHeaderAsync(client, objectAddr, tokenSource.Token)),
+ "hash" => (OracleResponseCode.Success, await GetHashAsync(client, objectAddr, ps.Skip(3).ToArray(), tokenSource.Token)),
+ _ => throw new Exception("invalid command")
+ };
+ }
+
+ private static (OracleResponseCode, string) GetPayload(Client client, Address addr, CancellationToken cancellation)
+ {
+ var objReader = client.GetObjectInit(addr, options: new CallOptions { Ttl = 2 }, context: cancellation);
+ var obj = objReader.ReadHeader();
+ if (obj.PayloadSize > OracleResponse.MaxResultSize)
+ return (OracleResponseCode.ResponseTooLarge, "");
+ var payload = new byte[obj.PayloadSize];
+ int offset = 0;
+ while (true)
+ {
+ if ((ulong)offset > obj.PayloadSize) return (OracleResponseCode.ResponseTooLarge, "");
+ (byte[] chunk, bool ok) = objReader.ReadChunk();
+ if (!ok) break;
+ Array.Copy(chunk, 0, payload, offset, chunk.Length);
+ offset += chunk.Length;
+ }
+ return (OracleResponseCode.Success, Utility.StrictUTF8.GetString(payload));
+ }
+
+ private static async Task<(OracleResponseCode, string)> GetRangeAsync(Client client, Address addr, string[] ps, CancellationToken cancellation)
+ {
+ if (ps.Length == 0) throw new FormatException("missing object range (expected 'Offset|Length')");
+ Range range = ParseRange(ps[0]);
+ if (range.Length > OracleResponse.MaxResultSize) return (OracleResponseCode.ResponseTooLarge, "");
+ var res = await client.GetObjectPayloadRangeData(addr, range, options: new CallOptions { Ttl = 2 }, context: cancellation);
+ return (OracleResponseCode.Success, Utility.StrictUTF8.GetString(res));
+ }
+
+ private static async Task GetHeaderAsync(Client client, Address addr, CancellationToken cancellation)
+ {
+ var obj = await client.GetObjectHeader(addr, options: new CallOptions { Ttl = 2 }, context: cancellation);
+ return obj.ToString();
+ }
+
+ private static async Task GetHashAsync(Client client, Address addr, string[] ps, CancellationToken cancellation)
+ {
+ if (ps.Length == 0 || ps[0] == "")
+ {
+ Object obj = await client.GetObjectHeader(addr, options: new CallOptions { Ttl = 2 }, context: cancellation);
+ return $"\"{new UInt256(obj.PayloadChecksum.Sum.ToByteArray())}\"";
+ }
+ Range range = ParseRange(ps[0]);
+ List hashes = await client.GetObjectPayloadRangeHash(addr, new List() { range }, ChecksumType.Sha256, Array.Empty(), new CallOptions { Ttl = 2 }, cancellation);
+ if (hashes.Count == 0) throw new Exception("empty response, object range is invalid (expected 'Offset|Length')");
+ return $"\"{new UInt256(hashes[0])}\"";
+ }
+
+ private static Range ParseRange(string s)
+ {
+ string url = HttpUtility.UrlDecode(s);
+ int sepIndex = url.IndexOf("|");
+ if (sepIndex < 0) throw new Exception("object range is invalid (expected 'Offset|Length')");
+ ulong offset = ulong.Parse(url[..sepIndex]);
+ ulong length = ulong.Parse(url[(sepIndex + 1)..]);
+ return new Range() { Offset = offset, Length = length };
+ }
+ }
+}
diff --git a/src/Plugins/OracleService/Settings.cs b/src/Plugins/OracleService/Settings.cs
new file mode 100644
index 0000000000..c66010cb5f
--- /dev/null
+++ b/src/Plugins/OracleService/Settings.cs
@@ -0,0 +1,72 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Settings.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Microsoft.Extensions.Configuration;
+using System;
+using System.Linq;
+
+namespace Neo.Plugins
+{
+ class HttpsSettings
+ {
+ public TimeSpan Timeout { get; }
+
+ public HttpsSettings(IConfigurationSection section)
+ {
+ Timeout = TimeSpan.FromMilliseconds(section.GetValue("Timeout", 5000));
+ }
+ }
+
+ class NeoFSSettings
+ {
+ public string EndPoint { get; }
+ public TimeSpan Timeout { get; }
+
+ public NeoFSSettings(IConfigurationSection section)
+ {
+ EndPoint = section.GetValue("EndPoint", "127.0.0.1:8080");
+ Timeout = TimeSpan.FromMilliseconds(section.GetValue("Timeout", 15000));
+ }
+ }
+
+ class Settings
+ {
+ public uint Network { get; }
+ public Uri[] Nodes { get; }
+ public TimeSpan MaxTaskTimeout { get; }
+ public TimeSpan MaxOracleTimeout { get; }
+ public bool AllowPrivateHost { get; }
+ public string[] AllowedContentTypes { get; }
+ public HttpsSettings Https { get; }
+ public NeoFSSettings NeoFS { get; }
+ public bool AutoStart { get; }
+
+ public static Settings Default { get; private set; }
+
+ private Settings(IConfigurationSection section)
+ {
+ Network = section.GetValue("Network", 5195086u);
+ Nodes = section.GetSection("Nodes").GetChildren().Select(p => new Uri(p.Get(), UriKind.Absolute)).ToArray();
+ MaxTaskTimeout = TimeSpan.FromMilliseconds(section.GetValue("MaxTaskTimeout", 432000000));
+ MaxOracleTimeout = TimeSpan.FromMilliseconds(section.GetValue("MaxOracleTimeout", 15000));
+ AllowPrivateHost = section.GetValue("AllowPrivateHost", false);
+ AllowedContentTypes = section.GetSection("AllowedContentTypes").GetChildren().Select(p => p.Get()).ToArray();
+ Https = new HttpsSettings(section.GetSection("Https"));
+ NeoFS = new NeoFSSettings(section.GetSection("NeoFS"));
+ AutoStart = section.GetValue("AutoStart", false);
+ }
+
+ public static void Load(IConfigurationSection section)
+ {
+ Default = new Settings(section);
+ }
+ }
+}
diff --git a/src/Plugins/OracleService/config.json b/src/Plugins/OracleService/config.json
new file mode 100644
index 0000000000..1ab0d93399
--- /dev/null
+++ b/src/Plugins/OracleService/config.json
@@ -0,0 +1,21 @@
+{
+ "PluginConfiguration": {
+ "Network": 860833102,
+ "Nodes": [],
+ "MaxTaskTimeout": 432000000,
+ "MaxOracleTimeout": 10000,
+ "AllowPrivateHost": false,
+ "AllowedContentTypes": [ "application/json" ],
+ "Https": {
+ "Timeout": 5000
+ },
+ "NeoFS": {
+ "EndPoint": "http://127.0.0.1:8080",
+ "Timeout": 15000
+ },
+ "AutoStart": false
+ },
+ "Dependency": [
+ "RpcServer"
+ ]
+}
diff --git a/src/Plugins/RocksDBStore/Plugins/Storage/Options.cs b/src/Plugins/RocksDBStore/Plugins/Storage/Options.cs
new file mode 100644
index 0000000000..26dd6c63aa
--- /dev/null
+++ b/src/Plugins/RocksDBStore/Plugins/Storage/Options.cs
@@ -0,0 +1,36 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Options.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using RocksDbSharp;
+
+namespace Neo.Plugins.Storage
+{
+ public static class Options
+ {
+ public static readonly DbOptions Default = CreateDbOptions();
+ public static readonly ReadOptions ReadDefault = new ReadOptions();
+ public static readonly WriteOptions WriteDefault = new WriteOptions();
+ public static readonly WriteOptions WriteDefaultSync = new WriteOptions().SetSync(true);
+
+ public static DbOptions CreateDbOptions()
+ {
+ DbOptions options = new DbOptions();
+ options.SetCreateMissingColumnFamilies(true);
+ options.SetCreateIfMissing(true);
+ options.SetErrorIfExists(false);
+ options.SetMaxOpenFiles(1000);
+ options.SetParanoidChecks(false);
+ options.SetWriteBufferSize(4 << 20);
+ options.SetBlockBasedTableFactory(new BlockBasedTableOptions().SetBlockSize(4096));
+ return options;
+ }
+ }
+}
diff --git a/src/Plugins/RocksDBStore/Plugins/Storage/RocksDBStore.cs b/src/Plugins/RocksDBStore/Plugins/Storage/RocksDBStore.cs
new file mode 100644
index 0000000000..079a012f67
--- /dev/null
+++ b/src/Plugins/RocksDBStore/Plugins/Storage/RocksDBStore.cs
@@ -0,0 +1,34 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RocksDBStore.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Persistence;
+
+namespace Neo.Plugins.Storage
+{
+ public class RocksDBStore : Plugin, IStoreProvider
+ {
+ public override string Description => "Uses RocksDBStore to store the blockchain data";
+
+ public RocksDBStore()
+ {
+ StoreFactory.RegisterProvider(this);
+ }
+
+ ///
+ /// Get store
+ ///
+ /// RocksDbStore
+ public IStore GetStore(string path)
+ {
+ return new Store(path);
+ }
+ }
+}
diff --git a/src/Plugins/RocksDBStore/Plugins/Storage/Snapshot.cs b/src/Plugins/RocksDBStore/Plugins/Storage/Snapshot.cs
new file mode 100644
index 0000000000..7423f6ae4a
--- /dev/null
+++ b/src/Plugins/RocksDBStore/Plugins/Storage/Snapshot.cs
@@ -0,0 +1,82 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Snapshot.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Persistence;
+using RocksDbSharp;
+using System;
+using System.Collections.Generic;
+
+namespace Neo.Plugins.Storage
+{
+ internal class Snapshot : ISnapshot
+ {
+ private readonly RocksDb db;
+ private readonly RocksDbSharp.Snapshot snapshot;
+ private readonly WriteBatch batch;
+ private readonly ReadOptions options;
+
+ public Snapshot(RocksDb db)
+ {
+ this.db = db;
+ snapshot = db.CreateSnapshot();
+ batch = new WriteBatch();
+
+ options = new ReadOptions();
+ options.SetFillCache(false);
+ options.SetSnapshot(snapshot);
+ }
+
+ public void Commit()
+ {
+ db.Write(batch, Options.WriteDefault);
+ }
+
+ public void Delete(byte[] key)
+ {
+ batch.Delete(key);
+ }
+
+ public void Put(byte[] key, byte[] value)
+ {
+ batch.Put(key, value);
+ }
+
+ public IEnumerable<(byte[] Key, byte[] Value)> Seek(byte[] keyOrPrefix, SeekDirection direction)
+ {
+ if (keyOrPrefix == null) keyOrPrefix = Array.Empty();
+
+ using var it = db.NewIterator(readOptions: options);
+
+ if (direction == SeekDirection.Forward)
+ for (it.Seek(keyOrPrefix); it.Valid(); it.Next())
+ yield return (it.Key(), it.Value());
+ else
+ for (it.SeekForPrev(keyOrPrefix); it.Valid(); it.Prev())
+ yield return (it.Key(), it.Value());
+ }
+
+ public bool Contains(byte[] key)
+ {
+ return db.Get(key, Array.Empty(), 0, 0, readOptions: options) >= 0;
+ }
+
+ public byte[] TryGet(byte[] key)
+ {
+ return db.Get(key, readOptions: options);
+ }
+
+ public void Dispose()
+ {
+ snapshot.Dispose();
+ batch.Dispose();
+ }
+ }
+}
diff --git a/src/Plugins/RocksDBStore/Plugins/Storage/Store.cs b/src/Plugins/RocksDBStore/Plugins/Storage/Store.cs
new file mode 100644
index 0000000000..ebf160dab0
--- /dev/null
+++ b/src/Plugins/RocksDBStore/Plugins/Storage/Store.cs
@@ -0,0 +1,77 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Store.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Persistence;
+using RocksDbSharp;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Neo.Plugins.Storage
+{
+ internal class Store : IStore
+ {
+ private readonly RocksDb db;
+
+ public Store(string path)
+ {
+ db = RocksDb.Open(Options.Default, Path.GetFullPath(path));
+ }
+
+ public void Dispose()
+ {
+ db.Dispose();
+ }
+
+ public ISnapshot GetSnapshot()
+ {
+ return new Snapshot(db);
+ }
+
+ public IEnumerable<(byte[] Key, byte[] Value)> Seek(byte[] keyOrPrefix, SeekDirection direction = SeekDirection.Forward)
+ {
+ if (keyOrPrefix == null) keyOrPrefix = Array.Empty();
+
+ using var it = db.NewIterator();
+ if (direction == SeekDirection.Forward)
+ for (it.Seek(keyOrPrefix); it.Valid(); it.Next())
+ yield return (it.Key(), it.Value());
+ else
+ for (it.SeekForPrev(keyOrPrefix); it.Valid(); it.Prev())
+ yield return (it.Key(), it.Value());
+ }
+
+ public bool Contains(byte[] key)
+ {
+ return db.Get(key, Array.Empty(), 0, 0) >= 0;
+ }
+
+ public byte[] TryGet(byte[] key)
+ {
+ return db.Get(key);
+ }
+
+ public void Delete(byte[] key)
+ {
+ db.Remove(key);
+ }
+
+ public void Put(byte[] key, byte[] value)
+ {
+ db.Put(key, value);
+ }
+
+ public void PutSync(byte[] key, byte[] value)
+ {
+ db.Put(key, value, writeOptions: Options.WriteDefaultSync);
+ }
+ }
+}
diff --git a/src/Plugins/RocksDBStore/RocksDBStore.csproj b/src/Plugins/RocksDBStore/RocksDBStore.csproj
new file mode 100644
index 0000000000..57037c68cf
--- /dev/null
+++ b/src/Plugins/RocksDBStore/RocksDBStore.csproj
@@ -0,0 +1,13 @@
+
+
+
+ net8.0
+ Neo.Plugins.Storage.RocksDBStore
+ Neo.Plugins.Storage
+
+
+
+
+
+
+
diff --git a/src/Plugins/RpcClient/ContractClient.cs b/src/Plugins/RpcClient/ContractClient.cs
new file mode 100644
index 0000000000..f4ec020abc
--- /dev/null
+++ b/src/Plugins/RpcClient/ContractClient.cs
@@ -0,0 +1,77 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ContractClient.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Network.P2P.Payloads;
+using Neo.Network.RPC.Models;
+using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
+using Neo.SmartContract.Native;
+using Neo.VM;
+using Neo.Wallets;
+using System.Threading.Tasks;
+
+namespace Neo.Network.RPC
+{
+ ///
+ /// Contract related operations through RPC API
+ ///
+ public class ContractClient
+ {
+ protected readonly RpcClient rpcClient;
+
+ ///
+ /// ContractClient Constructor
+ ///
+ /// the RPC client to call NEO RPC methods
+ public ContractClient(RpcClient rpc)
+ {
+ rpcClient = rpc;
+ }
+
+ ///
+ /// Use RPC method to test invoke operation.
+ ///
+ /// contract script hash
+ /// contract operation
+ /// operation arguments
+ ///
+ public Task TestInvokeAsync(UInt160 scriptHash, string operation, params object[] args)
+ {
+ byte[] script = scriptHash.MakeScript(operation, args);
+ return rpcClient.InvokeScriptAsync(script);
+ }
+
+ ///
+ /// Deploy Contract, return signed transaction
+ ///
+ /// neo contract executable file
+ /// contract manifest
+ /// sender KeyPair
+ ///
+ public async Task CreateDeployContractTxAsync(byte[] nefFile, ContractManifest manifest, KeyPair key)
+ {
+ byte[] script;
+ using (ScriptBuilder sb = new ScriptBuilder())
+ {
+ sb.EmitDynamicCall(NativeContract.ContractManagement.Hash, "deploy", nefFile, manifest.ToJson().ToString());
+ script = sb.ToArray();
+ }
+ UInt160 sender = Contract.CreateSignatureRedeemScript(key.PublicKey).ToScriptHash();
+ Signer[] signers = new[] { new Signer { Scopes = WitnessScope.CalledByEntry, Account = sender } };
+
+ TransactionManagerFactory factory = new TransactionManagerFactory(rpcClient);
+ TransactionManager manager = await factory.MakeTransactionAsync(script, signers).ConfigureAwait(false);
+ return await manager
+ .AddSignature(key)
+ .SignAsync().ConfigureAwait(false);
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcAccount.cs b/src/Plugins/RpcClient/Models/RpcAccount.cs
new file mode 100644
index 0000000000..2afe18b0e9
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcAccount.cs
@@ -0,0 +1,48 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcAccount.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcAccount
+ {
+ public string Address { get; set; }
+
+ public bool HasKey { get; set; }
+
+ public string Label { get; set; }
+
+ public bool WatchOnly { get; set; }
+
+ public JObject ToJson()
+ {
+ return new JObject
+ {
+ ["address"] = Address,
+ ["haskey"] = HasKey,
+ ["label"] = Label,
+ ["watchonly"] = WatchOnly
+ };
+ }
+
+ public static RpcAccount FromJson(JObject json)
+ {
+ return new RpcAccount
+ {
+ Address = json["address"].AsString(),
+ HasKey = json["haskey"].AsBoolean(),
+ Label = json["label"]?.AsString(),
+ WatchOnly = json["watchonly"].AsBoolean(),
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcApplicationLog.cs b/src/Plugins/RpcClient/Models/RpcApplicationLog.cs
new file mode 100644
index 0000000000..b641f9df06
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcApplicationLog.cs
@@ -0,0 +1,118 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcApplicationLog.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.SmartContract;
+using Neo.VM;
+using Neo.VM.Types;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcApplicationLog
+ {
+ public UInt256 TxId { get; set; }
+
+ public UInt256 BlockHash { get; set; }
+
+ public List Executions { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new JObject();
+ if (TxId != null)
+ json["txid"] = TxId.ToString();
+ if (BlockHash != null)
+ json["blockhash"] = BlockHash.ToString();
+ json["executions"] = Executions.Select(p => p.ToJson()).ToArray();
+ return json;
+ }
+
+ public static RpcApplicationLog FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ return new RpcApplicationLog
+ {
+ TxId = json["txid"] is null ? null : UInt256.Parse(json["txid"].AsString()),
+ BlockHash = json["blockhash"] is null ? null : UInt256.Parse(json["blockhash"].AsString()),
+ Executions = ((JArray)json["executions"]).Select(p => Execution.FromJson((JObject)p, protocolSettings)).ToList(),
+ };
+ }
+ }
+
+ public class Execution
+ {
+ public TriggerType Trigger { get; set; }
+
+ public VMState VMState { get; set; }
+
+ public long GasConsumed { get; set; }
+
+ public string ExceptionMessage { get; set; }
+
+ public List Stack { get; set; }
+
+ public List Notifications { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["trigger"] = Trigger;
+ json["vmstate"] = VMState;
+ json["gasconsumed"] = GasConsumed.ToString();
+ json["exception"] = ExceptionMessage;
+ json["stack"] = Stack.Select(q => q.ToJson()).ToArray();
+ json["notifications"] = Notifications.Select(q => q.ToJson()).ToArray();
+ return json;
+ }
+
+ public static Execution FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ return new Execution
+ {
+ Trigger = json["trigger"].GetEnum(),
+ VMState = json["vmstate"].GetEnum(),
+ GasConsumed = long.Parse(json["gasconsumed"].AsString()),
+ ExceptionMessage = json["exception"]?.AsString(),
+ Stack = ((JArray)json["stack"]).Select(p => Utility.StackItemFromJson((JObject)p)).ToList(),
+ Notifications = ((JArray)json["notifications"]).Select(p => RpcNotifyEventArgs.FromJson((JObject)p, protocolSettings)).ToList()
+ };
+ }
+ }
+
+ public class RpcNotifyEventArgs
+ {
+ public UInt160 Contract { get; set; }
+
+ public string EventName { get; set; }
+
+ public StackItem State { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["contract"] = Contract.ToString();
+ json["eventname"] = EventName;
+ json["state"] = State.ToJson();
+ return json;
+ }
+
+ public static RpcNotifyEventArgs FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ return new RpcNotifyEventArgs
+ {
+ Contract = json["contract"].ToScriptHash(protocolSettings),
+ EventName = json["eventname"].AsString(),
+ State = Utility.StackItemFromJson((JObject)json["state"])
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcBlock.cs b/src/Plugins/RpcClient/Models/RpcBlock.cs
new file mode 100644
index 0000000000..46f54a7230
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcBlock.cs
@@ -0,0 +1,43 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcBlock.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.Network.P2P.Payloads;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcBlock
+ {
+ public Block Block { get; set; }
+
+ public uint Confirmations { get; set; }
+
+ public UInt256 NextBlockHash { get; set; }
+
+ public JObject ToJson(ProtocolSettings protocolSettings)
+ {
+ JObject json = Utility.BlockToJson(Block, protocolSettings);
+ json["confirmations"] = Confirmations;
+ json["nextblockhash"] = NextBlockHash?.ToString();
+ return json;
+ }
+
+ public static RpcBlock FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ return new RpcBlock
+ {
+ Block = Utility.BlockFromJson(json, protocolSettings),
+ Confirmations = (uint)json["confirmations"].AsNumber(),
+ NextBlockHash = json["nextblockhash"] is null ? null : UInt256.Parse(json["nextblockhash"].AsString())
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcBlockHeader.cs b/src/Plugins/RpcClient/Models/RpcBlockHeader.cs
new file mode 100644
index 0000000000..e30a6a64a1
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcBlockHeader.cs
@@ -0,0 +1,43 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcBlockHeader.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.Network.P2P.Payloads;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcBlockHeader
+ {
+ public Header Header { get; set; }
+
+ public uint Confirmations { get; set; }
+
+ public UInt256 NextBlockHash { get; set; }
+
+ public JObject ToJson(ProtocolSettings protocolSettings)
+ {
+ JObject json = Header.ToJson(protocolSettings);
+ json["confirmations"] = Confirmations;
+ json["nextblockhash"] = NextBlockHash?.ToString();
+ return json;
+ }
+
+ public static RpcBlockHeader FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ return new RpcBlockHeader
+ {
+ Header = Utility.HeaderFromJson(json, protocolSettings),
+ Confirmations = (uint)json["confirmations"].AsNumber(),
+ NextBlockHash = json["nextblockhash"] is null ? null : UInt256.Parse(json["nextblockhash"].AsString())
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcContractState.cs b/src/Plugins/RpcClient/Models/RpcContractState.cs
new file mode 100644
index 0000000000..b77a2d3a89
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcContractState.cs
@@ -0,0 +1,42 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcContractState.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcContractState
+ {
+ public ContractState ContractState { get; set; }
+
+ public JObject ToJson()
+ {
+ return ContractState.ToJson();
+ }
+
+ public static RpcContractState FromJson(JObject json)
+ {
+ return new RpcContractState
+ {
+ ContractState = new ContractState
+ {
+ Id = (int)json["id"].AsNumber(),
+ UpdateCounter = (ushort)json["updatecounter"].AsNumber(),
+ Hash = UInt160.Parse(json["hash"].AsString()),
+ Nef = RpcNefFile.FromJson((JObject)json["nef"]),
+ Manifest = ContractManifest.FromJson((JObject)json["manifest"])
+ }
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcFoundStates.cs b/src/Plugins/RpcClient/Models/RpcFoundStates.cs
new file mode 100644
index 0000000000..a3a1c1f10a
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcFoundStates.cs
@@ -0,0 +1,44 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcFoundStates.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using System;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcFoundStates
+ {
+ public bool Truncated;
+ public (byte[] key, byte[] value)[] Results;
+ public byte[] FirstProof;
+ public byte[] LastProof;
+
+ public static RpcFoundStates FromJson(JObject json)
+ {
+ return new RpcFoundStates
+ {
+ Truncated = json["truncated"].AsBoolean(),
+ Results = ((JArray)json["results"])
+ .Select(j => (
+ Convert.FromBase64String(j["key"].AsString()),
+ Convert.FromBase64String(j["value"].AsString())
+ ))
+ .ToArray(),
+ FirstProof = ProofFromJson((JString)json["firstProof"]),
+ LastProof = ProofFromJson((JString)json["lastProof"]),
+ };
+ }
+
+ static byte[] ProofFromJson(JString json)
+ => json == null ? null : Convert.FromBase64String(json.AsString());
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcInvokeResult.cs b/src/Plugins/RpcClient/Models/RpcInvokeResult.cs
new file mode 100644
index 0000000000..6bd661e1ba
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcInvokeResult.cs
@@ -0,0 +1,100 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcInvokeResult.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.VM;
+using Neo.VM.Types;
+using System;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcInvokeResult
+ {
+ public string Script { get; set; }
+
+ public VM.VMState State { get; set; }
+
+ public long GasConsumed { get; set; }
+
+ public StackItem[] Stack { get; set; }
+
+ public string Tx { get; set; }
+
+ public string Exception { get; set; }
+
+ public string Session { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["script"] = Script;
+ json["state"] = State;
+ json["gasconsumed"] = GasConsumed.ToString();
+ if (!string.IsNullOrEmpty(Exception))
+ json["exception"] = Exception;
+ try
+ {
+ json["stack"] = new JArray(Stack.Select(p => p.ToJson()));
+ }
+ catch (InvalidOperationException)
+ {
+ // ContractParameter.ToJson() may cause InvalidOperationException
+ json["stack"] = "error: recursive reference";
+ }
+ if (!string.IsNullOrEmpty(Tx)) json["tx"] = Tx;
+ return json;
+ }
+
+ public static RpcInvokeResult FromJson(JObject json)
+ {
+ RpcInvokeResult invokeScriptResult = new()
+ {
+ Script = json["script"].AsString(),
+ State = json["state"].GetEnum(),
+ GasConsumed = long.Parse(json["gasconsumed"].AsString()),
+ Exception = json["exception"]?.AsString(),
+ Session = json["session"]?.AsString()
+ };
+ try
+ {
+ invokeScriptResult.Stack = ((JArray)json["stack"]).Select(p => Utility.StackItemFromJson((JObject)p)).ToArray();
+ }
+ catch { }
+ invokeScriptResult.Tx = json["tx"]?.AsString();
+ return invokeScriptResult;
+ }
+ }
+
+ public class RpcStack
+ {
+ public string Type { get; set; }
+
+ public string Value { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["type"] = Type;
+ json["value"] = Value;
+ return json;
+ }
+
+ public static RpcStack FromJson(JObject json)
+ {
+ return new RpcStack
+ {
+ Type = json["type"].AsString(),
+ Value = json["value"].AsString()
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcMethodToken.cs b/src/Plugins/RpcClient/Models/RpcMethodToken.cs
new file mode 100644
index 0000000000..f426950deb
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcMethodToken.cs
@@ -0,0 +1,32 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcMethodToken.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.SmartContract;
+using System;
+
+namespace Neo.Network.RPC.Models
+{
+ class RpcMethodToken
+ {
+ public static MethodToken FromJson(JObject json)
+ {
+ return new MethodToken
+ {
+ Hash = UInt160.Parse(json["hash"].AsString()),
+ Method = json["method"].AsString(),
+ ParametersCount = (ushort)json["paramcount"].AsNumber(),
+ HasReturnValue = json["hasreturnvalue"].AsBoolean(),
+ CallFlags = (CallFlags)Enum.Parse(typeof(CallFlags), json["callflags"].AsString())
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcNefFile.cs b/src/Plugins/RpcClient/Models/RpcNefFile.cs
new file mode 100644
index 0000000000..4b33f2b6ac
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcNefFile.cs
@@ -0,0 +1,33 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcNefFile.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.SmartContract;
+using System;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ class RpcNefFile
+ {
+ public static NefFile FromJson(JObject json)
+ {
+ return new NefFile
+ {
+ Compiler = json["compiler"].AsString(),
+ Source = json["source"].AsString(),
+ Tokens = ((JArray)json["tokens"]).Select(p => RpcMethodToken.FromJson((JObject)p)).ToArray(),
+ Script = Convert.FromBase64String(json["script"].AsString()),
+ CheckSum = (uint)json["checksum"].AsNumber()
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcNep17Balances.cs b/src/Plugins/RpcClient/Models/RpcNep17Balances.cs
new file mode 100644
index 0000000000..f7f8b00dbe
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcNep17Balances.cs
@@ -0,0 +1,73 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcNep17Balances.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.Wallets;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcNep17Balances
+ {
+ public UInt160 UserScriptHash { get; set; }
+
+ public List Balances { get; set; }
+
+ public JObject ToJson(ProtocolSettings protocolSettings)
+ {
+ JObject json = new();
+ json["balance"] = Balances.Select(p => p.ToJson()).ToArray();
+ json["address"] = UserScriptHash.ToAddress(protocolSettings.AddressVersion);
+ return json;
+ }
+
+ public static RpcNep17Balances FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ RpcNep17Balances nep17Balance = new()
+ {
+ Balances = ((JArray)json["balance"]).Select(p => RpcNep17Balance.FromJson((JObject)p, protocolSettings)).ToList(),
+ UserScriptHash = json["address"].ToScriptHash(protocolSettings)
+ };
+ return nep17Balance;
+ }
+ }
+
+ public class RpcNep17Balance
+ {
+ public UInt160 AssetHash { get; set; }
+
+ public BigInteger Amount { get; set; }
+
+ public uint LastUpdatedBlock { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["assethash"] = AssetHash.ToString();
+ json["amount"] = Amount.ToString();
+ json["lastupdatedblock"] = LastUpdatedBlock;
+ return json;
+ }
+
+ public static RpcNep17Balance FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ RpcNep17Balance balance = new()
+ {
+ AssetHash = json["assethash"].ToScriptHash(protocolSettings),
+ Amount = BigInteger.Parse(json["amount"].AsString()),
+ LastUpdatedBlock = (uint)json["lastupdatedblock"].AsNumber()
+ };
+ return balance;
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcNep17TokenInfo.cs b/src/Plugins/RpcClient/Models/RpcNep17TokenInfo.cs
new file mode 100644
index 0000000000..a7cb6d0ef4
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcNep17TokenInfo.cs
@@ -0,0 +1,26 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcNep17TokenInfo.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System.Numerics;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcNep17TokenInfo
+ {
+ public string Name { get; set; }
+
+ public string Symbol { get; set; }
+
+ public byte Decimals { get; set; }
+
+ public BigInteger TotalSupply { get; set; }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcNep17Transfers.cs b/src/Plugins/RpcClient/Models/RpcNep17Transfers.cs
new file mode 100644
index 0000000000..3a3226b9a9
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcNep17Transfers.cs
@@ -0,0 +1,92 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcNep17Transfers.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.Wallets;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcNep17Transfers
+ {
+ public UInt160 UserScriptHash { get; set; }
+
+ public List Sent { get; set; }
+
+ public List Received { get; set; }
+
+ public JObject ToJson(ProtocolSettings protocolSettings)
+ {
+ JObject json = new();
+ json["sent"] = Sent.Select(p => p.ToJson(protocolSettings)).ToArray();
+ json["received"] = Received.Select(p => p.ToJson(protocolSettings)).ToArray();
+ json["address"] = UserScriptHash.ToAddress(protocolSettings.AddressVersion);
+ return json;
+ }
+
+ public static RpcNep17Transfers FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ RpcNep17Transfers transfers = new()
+ {
+ Sent = ((JArray)json["sent"]).Select(p => RpcNep17Transfer.FromJson((JObject)p, protocolSettings)).ToList(),
+ Received = ((JArray)json["received"]).Select(p => RpcNep17Transfer.FromJson((JObject)p, protocolSettings)).ToList(),
+ UserScriptHash = json["address"].ToScriptHash(protocolSettings)
+ };
+ return transfers;
+ }
+ }
+
+ public class RpcNep17Transfer
+ {
+ public ulong TimestampMS { get; set; }
+
+ public UInt160 AssetHash { get; set; }
+
+ public UInt160 UserScriptHash { get; set; }
+
+ public BigInteger Amount { get; set; }
+
+ public uint BlockIndex { get; set; }
+
+ public ushort TransferNotifyIndex { get; set; }
+
+ public UInt256 TxHash { get; set; }
+
+ public JObject ToJson(ProtocolSettings protocolSettings)
+ {
+ JObject json = new();
+ json["timestamp"] = TimestampMS;
+ json["assethash"] = AssetHash.ToString();
+ json["transferaddress"] = UserScriptHash?.ToAddress(protocolSettings.AddressVersion);
+ json["amount"] = Amount.ToString();
+ json["blockindex"] = BlockIndex;
+ json["transfernotifyindex"] = TransferNotifyIndex;
+ json["txhash"] = TxHash.ToString();
+ return json;
+ }
+
+ public static RpcNep17Transfer FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ return new RpcNep17Transfer
+ {
+ TimestampMS = (ulong)json["timestamp"].AsNumber(),
+ AssetHash = json["assethash"].ToScriptHash(protocolSettings),
+ UserScriptHash = json["transferaddress"]?.ToScriptHash(protocolSettings),
+ Amount = BigInteger.Parse(json["amount"].AsString()),
+ BlockIndex = (uint)json["blockindex"].AsNumber(),
+ TransferNotifyIndex = (ushort)json["transfernotifyindex"].AsNumber(),
+ TxHash = UInt256.Parse(json["txhash"].AsString())
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcPeers.cs b/src/Plugins/RpcClient/Models/RpcPeers.cs
new file mode 100644
index 0000000000..6659ffe0dd
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcPeers.cs
@@ -0,0 +1,68 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcPeers.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcPeers
+ {
+ public RpcPeer[] Unconnected { get; set; }
+
+ public RpcPeer[] Bad { get; set; }
+
+ public RpcPeer[] Connected { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["unconnected"] = new JArray(Unconnected.Select(p => p.ToJson()));
+ json["bad"] = new JArray(Bad.Select(p => p.ToJson()));
+ json["connected"] = new JArray(Connected.Select(p => p.ToJson()));
+ return json;
+ }
+
+ public static RpcPeers FromJson(JObject json)
+ {
+ return new RpcPeers
+ {
+ Unconnected = ((JArray)json["unconnected"]).Select(p => RpcPeer.FromJson((JObject)p)).ToArray(),
+ Bad = ((JArray)json["bad"]).Select(p => RpcPeer.FromJson((JObject)p)).ToArray(),
+ Connected = ((JArray)json["connected"]).Select(p => RpcPeer.FromJson((JObject)p)).ToArray()
+ };
+ }
+ }
+
+ public class RpcPeer
+ {
+ public string Address { get; set; }
+
+ public int Port { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["address"] = Address;
+ json["port"] = Port;
+ return json;
+ }
+
+ public static RpcPeer FromJson(JObject json)
+ {
+ return new RpcPeer
+ {
+ Address = json["address"].AsString(),
+ Port = int.Parse(json["port"].AsString())
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcPlugin.cs b/src/Plugins/RpcClient/Models/RpcPlugin.cs
new file mode 100644
index 0000000000..12a8669dea
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcPlugin.cs
@@ -0,0 +1,44 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcPlugin.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcPlugin
+ {
+ public string Name { get; set; }
+
+ public string Version { get; set; }
+
+ public string[] Interfaces { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["name"] = Name;
+ json["version"] = Version;
+ json["interfaces"] = new JArray(Interfaces.Select(p => (JToken)p));
+ return json;
+ }
+
+ public static RpcPlugin FromJson(JObject json)
+ {
+ return new RpcPlugin
+ {
+ Name = json["name"].AsString(),
+ Version = json["version"].AsString(),
+ Interfaces = ((JArray)json["interfaces"]).Select(p => p.AsString()).ToArray()
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcRawMemPool.cs b/src/Plugins/RpcClient/Models/RpcRawMemPool.cs
new file mode 100644
index 0000000000..4474e0b6be
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcRawMemPool.cs
@@ -0,0 +1,45 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcRawMemPool.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcRawMemPool
+ {
+ public uint Height { get; set; }
+
+ public List Verified { get; set; }
+
+ public List UnVerified { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["height"] = Height;
+ json["verified"] = new JArray(Verified.Select(p => (JToken)p.ToString()));
+ json["unverified"] = new JArray(UnVerified.Select(p => (JToken)p.ToString()));
+ return json;
+ }
+
+ public static RpcRawMemPool FromJson(JObject json)
+ {
+ return new RpcRawMemPool
+ {
+ Height = uint.Parse(json["height"].AsString()),
+ Verified = ((JArray)json["verified"]).Select(p => UInt256.Parse(p.AsString())).ToList(),
+ UnVerified = ((JArray)json["unverified"]).Select(p => UInt256.Parse(p.AsString())).ToList()
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcRequest.cs b/src/Plugins/RpcClient/Models/RpcRequest.cs
new file mode 100644
index 0000000000..1c4b67415a
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcRequest.cs
@@ -0,0 +1,48 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcRequest.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcRequest
+ {
+ public JToken Id { get; set; }
+
+ public string JsonRpc { get; set; }
+
+ public string Method { get; set; }
+
+ public JToken[] Params { get; set; }
+
+ public static RpcRequest FromJson(JObject json)
+ {
+ return new RpcRequest
+ {
+ Id = json["id"],
+ JsonRpc = json["jsonrpc"].AsString(),
+ Method = json["method"].AsString(),
+ Params = ((JArray)json["params"]).ToArray()
+ };
+ }
+
+ public JObject ToJson()
+ {
+ var json = new JObject();
+ json["id"] = Id;
+ json["jsonrpc"] = JsonRpc;
+ json["method"] = Method;
+ json["params"] = new JArray(Params);
+ return json;
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcResponse.cs b/src/Plugins/RpcClient/Models/RpcResponse.cs
new file mode 100644
index 0000000000..25e3212fc3
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcResponse.cs
@@ -0,0 +1,83 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcResponse.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcResponse
+ {
+ public JToken Id { get; set; }
+
+ public string JsonRpc { get; set; }
+
+ public RpcResponseError Error { get; set; }
+
+ public JToken Result { get; set; }
+
+ public string RawResponse { get; set; }
+
+ public static RpcResponse FromJson(JObject json)
+ {
+ RpcResponse response = new()
+ {
+ Id = json["id"],
+ JsonRpc = json["jsonrpc"].AsString(),
+ Result = json["result"]
+ };
+
+ if (json["error"] != null)
+ {
+ response.Error = RpcResponseError.FromJson((JObject)json["error"]);
+ }
+
+ return response;
+ }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["id"] = Id;
+ json["jsonrpc"] = JsonRpc;
+ json["error"] = Error?.ToJson();
+ json["result"] = Result;
+ return json;
+ }
+ }
+
+ public class RpcResponseError
+ {
+ public int Code { get; set; }
+
+ public string Message { get; set; }
+
+ public JToken Data { get; set; }
+
+ public static RpcResponseError FromJson(JObject json)
+ {
+ return new RpcResponseError
+ {
+ Code = (int)json["code"].AsNumber(),
+ Message = json["message"].AsString(),
+ Data = json["data"],
+ };
+ }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["code"] = Code;
+ json["message"] = Message;
+ json["data"] = Data;
+ return json;
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcStateRoot.cs b/src/Plugins/RpcClient/Models/RpcStateRoot.cs
new file mode 100644
index 0000000000..095b054a33
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcStateRoot.cs
@@ -0,0 +1,36 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcStateRoot.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.Network.P2P.Payloads;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcStateRoot
+ {
+ public byte Version;
+ public uint Index;
+ public UInt256 RootHash;
+ public Witness Witness;
+
+ public static RpcStateRoot FromJson(JObject json)
+ {
+ return new RpcStateRoot
+ {
+ Version = (byte)json["version"].AsNumber(),
+ Index = (uint)json["index"].AsNumber(),
+ RootHash = UInt256.Parse(json["roothash"].AsString()),
+ Witness = ((JArray)json["witnesses"]).Select(p => Utility.WitnessFromJson((JObject)p)).FirstOrDefault()
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcTransaction.cs b/src/Plugins/RpcClient/Models/RpcTransaction.cs
new file mode 100644
index 0000000000..cb674316d5
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcTransaction.cs
@@ -0,0 +1,62 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcTransaction.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.Network.P2P.Payloads;
+using Neo.VM;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcTransaction
+ {
+ public Transaction Transaction { get; set; }
+
+ public UInt256 BlockHash { get; set; }
+
+ public uint? Confirmations { get; set; }
+
+ public ulong? BlockTime { get; set; }
+
+ public VMState? VMState { get; set; }
+
+ public JObject ToJson(ProtocolSettings protocolSettings)
+ {
+ JObject json = Utility.TransactionToJson(Transaction, protocolSettings);
+ if (Confirmations != null)
+ {
+ json["blockhash"] = BlockHash.ToString();
+ json["confirmations"] = Confirmations;
+ json["blocktime"] = BlockTime;
+ if (VMState != null)
+ {
+ json["vmstate"] = VMState;
+ }
+ }
+ return json;
+ }
+
+ public static RpcTransaction FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ RpcTransaction transaction = new RpcTransaction
+ {
+ Transaction = Utility.TransactionFromJson(json, protocolSettings)
+ };
+ if (json["confirmations"] != null)
+ {
+ transaction.BlockHash = UInt256.Parse(json["blockhash"].AsString());
+ transaction.Confirmations = (uint)json["confirmations"].AsNumber();
+ transaction.BlockTime = (ulong)json["blocktime"].AsNumber();
+ transaction.VMState = json["vmstate"]?.GetEnum();
+ }
+ return transaction;
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcTransferOut.cs b/src/Plugins/RpcClient/Models/RpcTransferOut.cs
new file mode 100644
index 0000000000..d5e82a8468
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcTransferOut.cs
@@ -0,0 +1,45 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcTransferOut.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using Neo.Wallets;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcTransferOut
+ {
+ public UInt160 Asset { get; set; }
+
+ public UInt160 ScriptHash { get; set; }
+
+ public string Value { get; set; }
+
+ public JObject ToJson(ProtocolSettings protocolSettings)
+ {
+ return new JObject
+ {
+ ["asset"] = Asset.ToString(),
+ ["value"] = Value,
+ ["address"] = ScriptHash.ToAddress(protocolSettings.AddressVersion),
+ };
+ }
+
+ public static RpcTransferOut FromJson(JObject json, ProtocolSettings protocolSettings)
+ {
+ return new RpcTransferOut
+ {
+ Asset = json["asset"].ToScriptHash(protocolSettings),
+ Value = json["value"].AsString(),
+ ScriptHash = json["address"].ToScriptHash(protocolSettings),
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcUnclaimedGas.cs b/src/Plugins/RpcClient/Models/RpcUnclaimedGas.cs
new file mode 100644
index 0000000000..c25f527d33
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcUnclaimedGas.cs
@@ -0,0 +1,39 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcUnclaimedGas.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcUnclaimedGas
+ {
+ public long Unclaimed { get; set; }
+
+ public string Address { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["unclaimed"] = Unclaimed.ToString();
+ json["address"] = Address;
+ return json;
+ }
+
+ public static RpcUnclaimedGas FromJson(JObject json)
+ {
+ return new RpcUnclaimedGas
+ {
+ Unclaimed = long.Parse(json["unclaimed"].AsString()),
+ Address = json["address"].AsString()
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcValidateAddressResult.cs b/src/Plugins/RpcClient/Models/RpcValidateAddressResult.cs
new file mode 100644
index 0000000000..6f49e08f06
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcValidateAddressResult.cs
@@ -0,0 +1,39 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcValidateAddressResult.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcValidateAddressResult
+ {
+ public string Address { get; set; }
+
+ public bool IsValid { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["address"] = Address;
+ json["isvalid"] = IsValid;
+ return json;
+ }
+
+ public static RpcValidateAddressResult FromJson(JObject json)
+ {
+ return new RpcValidateAddressResult
+ {
+ Address = json["address"].AsString(),
+ IsValid = json["isvalid"].AsBoolean()
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcValidator.cs b/src/Plugins/RpcClient/Models/RpcValidator.cs
new file mode 100644
index 0000000000..27031631e9
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcValidator.cs
@@ -0,0 +1,40 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcValidator.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using System.Numerics;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcValidator
+ {
+ public string PublicKey { get; set; }
+
+ public BigInteger Votes { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["publickey"] = PublicKey;
+ json["votes"] = Votes.ToString();
+ return json;
+ }
+
+ public static RpcValidator FromJson(JObject json)
+ {
+ return new RpcValidator
+ {
+ PublicKey = json["publickey"].AsString(),
+ Votes = BigInteger.Parse(json["votes"].AsString()),
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Models/RpcVersion.cs b/src/Plugins/RpcClient/Models/RpcVersion.cs
new file mode 100644
index 0000000000..430d659f7c
--- /dev/null
+++ b/src/Plugins/RpcClient/Models/RpcVersion.cs
@@ -0,0 +1,113 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcVersion.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Neo.Network.RPC.Models
+{
+ public class RpcVersion
+ {
+ public class RpcProtocol
+ {
+ public uint Network { get; set; }
+ public int ValidatorsCount { get; set; }
+ public uint MillisecondsPerBlock { get; set; }
+ public uint MaxValidUntilBlockIncrement { get; set; }
+ public uint MaxTraceableBlocks { get; set; }
+ public byte AddressVersion { get; set; }
+ public uint MaxTransactionsPerBlock { get; set; }
+ public int MemoryPoolMaxTransactions { get; set; }
+ public ulong InitialGasDistribution { get; set; }
+ public IReadOnlyDictionary Hardforks { get; set; }
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["network"] = Network;
+ json["validatorscount"] = ValidatorsCount;
+ json["msperblock"] = MillisecondsPerBlock;
+ json["maxvaliduntilblockincrement"] = MaxValidUntilBlockIncrement;
+ json["maxtraceableblocks"] = MaxTraceableBlocks;
+ json["addressversion"] = AddressVersion;
+ json["maxtransactionsperblock"] = MaxTransactionsPerBlock;
+ json["memorypoolmaxtransactions"] = MemoryPoolMaxTransactions;
+ json["initialgasdistribution"] = InitialGasDistribution;
+ json["hardforks"] = new JArray(Hardforks.Select(s => new JObject()
+ {
+ // Strip HF_ prefix.
+ ["name"] = StripPrefix(s.Key.ToString(), "HF_"),
+ ["blockheight"] = s.Value,
+ }));
+ return json;
+ }
+
+ public static RpcProtocol FromJson(JObject json)
+ {
+ return new()
+ {
+ Network = (uint)json["network"].AsNumber(),
+ ValidatorsCount = (int)json["validatorscount"].AsNumber(),
+ MillisecondsPerBlock = (uint)json["msperblock"].AsNumber(),
+ MaxValidUntilBlockIncrement = (uint)json["maxvaliduntilblockincrement"].AsNumber(),
+ MaxTraceableBlocks = (uint)json["maxtraceableblocks"].AsNumber(),
+ AddressVersion = (byte)json["addressversion"].AsNumber(),
+ MaxTransactionsPerBlock = (uint)json["maxtransactionsperblock"].AsNumber(),
+ MemoryPoolMaxTransactions = (int)json["memorypoolmaxtransactions"].AsNumber(),
+ InitialGasDistribution = (ulong)json["initialgasdistribution"].AsNumber(),
+ Hardforks = new Dictionary(((JArray)json["hardforks"]).Select(s =>
+ {
+ var name = s["name"].AsString();
+ // Add HF_ prefix to the hardfork response for proper Hardfork enum parsing.
+ return new KeyValuePair(Enum.Parse(name.StartsWith("HF_") ? name : $"HF_{name}"), (uint)s["blockheight"].AsNumber());
+ })),
+ };
+ }
+
+ private static string StripPrefix(string s, string prefix)
+ {
+ return s.StartsWith(prefix) ? s.Substring(prefix.Length) : s;
+ }
+ }
+
+ public int TcpPort { get; set; }
+
+ public uint Nonce { get; set; }
+
+ public string UserAgent { get; set; }
+
+ public RpcProtocol Protocol { get; set; } = new();
+
+ public JObject ToJson()
+ {
+ JObject json = new();
+ json["network"] = Protocol.Network; // Obsolete
+ json["tcpport"] = TcpPort;
+ json["nonce"] = Nonce;
+ json["useragent"] = UserAgent;
+ json["protocol"] = Protocol.ToJson();
+ return json;
+ }
+
+ public static RpcVersion FromJson(JObject json)
+ {
+ return new()
+ {
+ TcpPort = (int)json["tcpport"].AsNumber(),
+ Nonce = (uint)json["nonce"].AsNumber(),
+ UserAgent = json["useragent"].AsString(),
+ Protocol = RpcProtocol.FromJson((JObject)json["protocol"])
+ };
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Nep17API.cs b/src/Plugins/RpcClient/Nep17API.cs
new file mode 100644
index 0000000000..518f470924
--- /dev/null
+++ b/src/Plugins/RpcClient/Nep17API.cs
@@ -0,0 +1,182 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Nep17API.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.Cryptography.ECC;
+using Neo.Network.P2P.Payloads;
+using Neo.Network.RPC.Models;
+using Neo.SmartContract;
+using Neo.VM;
+using Neo.Wallets;
+using System;
+using System.Linq;
+using System.Numerics;
+using System.Threading.Tasks;
+using static Neo.Helper;
+
+namespace Neo.Network.RPC
+{
+ ///
+ /// Call NEP17 methods with RPC API
+ ///
+ public class Nep17API : ContractClient
+ {
+ ///
+ /// Nep17API Constructor
+ ///
+ /// the RPC client to call NEO RPC methods
+ public Nep17API(RpcClient rpcClient) : base(rpcClient) { }
+
+ ///
+ /// Get balance of NEP17 token
+ ///
+ /// contract script hash
+ /// account script hash
+ ///
+ public async Task BalanceOfAsync(UInt160 scriptHash, UInt160 account)
+ {
+ var result = await TestInvokeAsync(scriptHash, "balanceOf", account).ConfigureAwait(false);
+ BigInteger balance = result.Stack.Single().GetInteger();
+ return balance;
+ }
+
+ ///
+ /// Get symbol of NEP17 token
+ ///
+ /// contract script hash
+ ///
+ public async Task SymbolAsync(UInt160 scriptHash)
+ {
+ var result = await TestInvokeAsync(scriptHash, "symbol").ConfigureAwait(false);
+ return result.Stack.Single().GetString();
+ }
+
+ ///
+ /// Get decimals of NEP17 token
+ ///
+ /// contract script hash
+ ///
+ public async Task DecimalsAsync(UInt160 scriptHash)
+ {
+ var result = await TestInvokeAsync(scriptHash, "decimals").ConfigureAwait(false);
+ return (byte)result.Stack.Single().GetInteger();
+ }
+
+ ///
+ /// Get total supply of NEP17 token
+ ///
+ /// contract script hash
+ ///
+ public async Task TotalSupplyAsync(UInt160 scriptHash)
+ {
+ var result = await TestInvokeAsync(scriptHash, "totalSupply").ConfigureAwait(false);
+ return result.Stack.Single().GetInteger();
+ }
+
+ ///
+ /// Get token information in one rpc call
+ ///
+ /// contract script hash
+ ///
+ public async Task GetTokenInfoAsync(UInt160 scriptHash)
+ {
+ var contractState = await rpcClient.GetContractStateAsync(scriptHash.ToString()).ConfigureAwait(false);
+ byte[] script = Concat(
+ scriptHash.MakeScript("symbol"),
+ scriptHash.MakeScript("decimals"),
+ scriptHash.MakeScript("totalSupply"));
+ var name = contractState.Manifest.Name;
+ var result = await rpcClient.InvokeScriptAsync(script).ConfigureAwait(false);
+ var stack = result.Stack;
+
+ return new RpcNep17TokenInfo
+ {
+ Name = name,
+ Symbol = stack[0].GetString(),
+ Decimals = (byte)stack[1].GetInteger(),
+ TotalSupply = stack[2].GetInteger()
+ };
+ }
+
+ public async Task GetTokenInfoAsync(string contractHash)
+ {
+ var contractState = await rpcClient.GetContractStateAsync(contractHash).ConfigureAwait(false);
+ byte[] script = Concat(
+ contractState.Hash.MakeScript("symbol"),
+ contractState.Hash.MakeScript("decimals"),
+ contractState.Hash.MakeScript("totalSupply"));
+ var name = contractState.Manifest.Name;
+ var result = await rpcClient.InvokeScriptAsync(script).ConfigureAwait(false);
+ var stack = result.Stack;
+
+ return new RpcNep17TokenInfo
+ {
+ Name = name,
+ Symbol = stack[0].GetString(),
+ Decimals = (byte)stack[1].GetInteger(),
+ TotalSupply = stack[2].GetInteger()
+ };
+ }
+
+ ///
+ /// Create NEP17 token transfer transaction
+ ///
+ /// contract script hash
+ /// from KeyPair
+ /// to account script hash
+ /// transfer amount
+ /// onPayment data
+ /// Add assert at the end of the script
+ ///
+ public async Task CreateTransferTxAsync(UInt160 scriptHash, KeyPair fromKey, UInt160 to, BigInteger amount, object data = null, bool addAssert = true)
+ {
+ var sender = Contract.CreateSignatureRedeemScript(fromKey.PublicKey).ToScriptHash();
+ Signer[] signers = new[] { new Signer { Scopes = WitnessScope.CalledByEntry, Account = sender } };
+ byte[] script = scriptHash.MakeScript("transfer", sender, to, amount, data);
+ if (addAssert) script = script.Concat(new[] { (byte)OpCode.ASSERT }).ToArray();
+
+ TransactionManagerFactory factory = new(rpcClient);
+ TransactionManager manager = await factory.MakeTransactionAsync(script, signers).ConfigureAwait(false);
+
+ return await manager
+ .AddSignature(fromKey)
+ .SignAsync().ConfigureAwait(false);
+ }
+
+ ///
+ /// Create NEP17 token transfer transaction from multi-sig account
+ ///
+ /// contract script hash
+ /// multi-sig min signature count
+ /// multi-sig pubKeys
+ /// sign keys
+ /// to account
+ /// transfer amount
+ /// onPayment data
+ /// Add assert at the end of the script
+ ///
+ public async Task CreateTransferTxAsync(UInt160 scriptHash, int m, ECPoint[] pubKeys, KeyPair[] fromKeys, UInt160 to, BigInteger amount, object data = null, bool addAssert = true)
+ {
+ if (m > fromKeys.Length)
+ throw new ArgumentException($"Need at least {m} KeyPairs for signing!");
+ var sender = Contract.CreateMultiSigContract(m, pubKeys).ScriptHash;
+ Signer[] signers = new[] { new Signer { Scopes = WitnessScope.CalledByEntry, Account = sender } };
+ byte[] script = scriptHash.MakeScript("transfer", sender, to, amount, data);
+ if (addAssert) script = script.Concat(new[] { (byte)OpCode.ASSERT }).ToArray();
+
+ TransactionManagerFactory factory = new(rpcClient);
+ TransactionManager manager = await factory.MakeTransactionAsync(script, signers).ConfigureAwait(false);
+
+ return await manager
+ .AddMultiSig(fromKeys, m, pubKeys)
+ .SignAsync().ConfigureAwait(false);
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/PolicyAPI.cs b/src/Plugins/RpcClient/PolicyAPI.cs
new file mode 100644
index 0000000000..60e749a79c
--- /dev/null
+++ b/src/Plugins/RpcClient/PolicyAPI.cs
@@ -0,0 +1,71 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// PolicyAPI.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.SmartContract.Native;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Neo.Network.RPC
+{
+ ///
+ /// Get Policy info by RPC API
+ ///
+ public class PolicyAPI : ContractClient
+ {
+ readonly UInt160 scriptHash = NativeContract.Policy.Hash;
+
+ ///
+ /// PolicyAPI Constructor
+ ///
+ /// the RPC client to call NEO RPC methods
+ public PolicyAPI(RpcClient rpcClient) : base(rpcClient) { }
+
+ ///
+ /// Get Fee Factor
+ ///
+ ///
+ public async Task GetExecFeeFactorAsync()
+ {
+ var result = await TestInvokeAsync(scriptHash, "getExecFeeFactor").ConfigureAwait(false);
+ return (uint)result.Stack.Single().GetInteger();
+ }
+
+ ///
+ /// Get Storage Price
+ ///
+ ///
+ public async Task GetStoragePriceAsync()
+ {
+ var result = await TestInvokeAsync(scriptHash, "getStoragePrice").ConfigureAwait(false);
+ return (uint)result.Stack.Single().GetInteger();
+ }
+
+ ///
+ /// Get Network Fee Per Byte
+ ///
+ ///
+ public async Task GetFeePerByteAsync()
+ {
+ var result = await TestInvokeAsync(scriptHash, "getFeePerByte").ConfigureAwait(false);
+ return (long)result.Stack.Single().GetInteger();
+ }
+
+ ///
+ /// Get Ploicy Blocked Accounts
+ ///
+ ///
+ public async Task IsBlockedAsync(UInt160 account)
+ {
+ var result = await TestInvokeAsync(scriptHash, "isBlocked", new object[] { account }).ConfigureAwait(false);
+ return result.Stack.Single().GetBoolean();
+ }
+ }
+}
diff --git a/src/Plugins/RpcClient/Properties/AssemblyInfo.cs b/src/Plugins/RpcClient/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000000..d464f67da1
--- /dev/null
+++ b/src/Plugins/RpcClient/Properties/AssemblyInfo.cs
@@ -0,0 +1,14 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// AssemblyInfo.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Neo.Network.RPC.Tests")]
diff --git a/src/Plugins/RpcClient/RpcClient.cs b/src/Plugins/RpcClient/RpcClient.cs
new file mode 100644
index 0000000000..27b0023ec0
--- /dev/null
+++ b/src/Plugins/RpcClient/RpcClient.cs
@@ -0,0 +1,712 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// RpcClient.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.IO;
+using Neo.Json;
+using Neo.Network.P2P.Payloads;
+using Neo.Network.RPC.Models;
+using Neo.SmartContract;
+using Neo.SmartContract.Manifest;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace Neo.Network.RPC
+{
+ ///
+ /// The RPC client to call NEO RPC methods
+ ///
+ public class RpcClient : IDisposable
+ {
+ private readonly HttpClient httpClient;
+ private readonly Uri baseAddress;
+ internal readonly ProtocolSettings protocolSettings;
+
+ public RpcClient(Uri url, string rpcUser = default, string rpcPass = default, ProtocolSettings protocolSettings = null)
+ {
+ httpClient = new HttpClient();
+ baseAddress = url;
+ if (!string.IsNullOrEmpty(rpcUser) && !string.IsNullOrEmpty(rpcPass))
+ {
+ string token = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{rpcUser}:{rpcPass}"));
+ httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", token);
+ }
+ this.protocolSettings = protocolSettings ?? ProtocolSettings.Default;
+ }
+
+ public RpcClient(HttpClient client, Uri url, ProtocolSettings protocolSettings = null)
+ {
+ httpClient = client;
+ baseAddress = url;
+ this.protocolSettings = protocolSettings ?? ProtocolSettings.Default;
+ }
+
+ #region IDisposable Support
+ private bool disposedValue = false; // To detect redundant calls
+
+ protected virtual void Dispose(bool disposing)
+ {
+ if (!disposedValue)
+ {
+ if (disposing)
+ {
+ httpClient.Dispose();
+ }
+
+ disposedValue = true;
+ }
+ }
+
+ public void Dispose()
+ {
+ Dispose(true);
+ }
+ #endregion
+
+ static RpcRequest AsRpcRequest(string method, params JToken[] paraArgs)
+ {
+ return new RpcRequest
+ {
+ Id = 1,
+ JsonRpc = "2.0",
+ Method = method,
+ Params = paraArgs
+ };
+ }
+
+ static RpcResponse AsRpcResponse(string content, bool throwOnError)
+ {
+ var response = RpcResponse.FromJson((JObject)JToken.Parse(content));
+ response.RawResponse = content;
+
+ if (response.Error != null && throwOnError)
+ {
+ throw new RpcException(response.Error.Code, response.Error.Message);
+ }
+
+ return response;
+ }
+
+ HttpRequestMessage AsHttpRequest(RpcRequest request)
+ {
+ var requestJson = request.ToJson().ToString();
+ return new HttpRequestMessage(HttpMethod.Post, baseAddress)
+ {
+ Content = new StringContent(requestJson, Neo.Utility.StrictUTF8)
+ };
+ }
+
+ public RpcResponse Send(RpcRequest request, bool throwOnError = true)
+ {
+ if (disposedValue) throw new ObjectDisposedException(nameof(RpcClient));
+
+ using var requestMsg = AsHttpRequest(request);
+ using var responseMsg = httpClient.Send(requestMsg);
+ using var contentStream = responseMsg.Content.ReadAsStream();
+ using var contentReader = new StreamReader(contentStream);
+ return AsRpcResponse(contentReader.ReadToEnd(), throwOnError);
+ }
+
+ public async Task SendAsync(RpcRequest request, bool throwOnError = true)
+ {
+ if (disposedValue) throw new ObjectDisposedException(nameof(RpcClient));
+
+ using var requestMsg = AsHttpRequest(request);
+ using var responseMsg = await httpClient.SendAsync(requestMsg).ConfigureAwait(false);
+ var content = await responseMsg.Content.ReadAsStringAsync();
+ return AsRpcResponse(content, throwOnError);
+ }
+
+ public virtual JToken RpcSend(string method, params JToken[] paraArgs)
+ {
+ var request = AsRpcRequest(method, paraArgs);
+ var response = Send(request);
+ return response.Result;
+ }
+
+ public virtual async Task RpcSendAsync(string method, params JToken[] paraArgs)
+ {
+ var request = AsRpcRequest(method, paraArgs);
+ var response = await SendAsync(request).ConfigureAwait(false);
+ return response.Result;
+ }
+
+ public static string GetRpcName([CallerMemberName] string methodName = null)
+ {
+ return new Regex("(.*?)(Hex|Both)?(Async)?").Replace(methodName, "$1").ToLowerInvariant();
+ }
+
+ #region Blockchain
+
+ ///
+ /// Returns the hash of the tallest block in the main chain.
+ ///
+ public async Task GetBestBlockHashAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return result.AsString();
+ }
+
+ ///
+ /// Returns the hash of the tallest block in the main chain.
+ /// The serialized information of the block is returned, represented by a hexadecimal string.
+ ///
+ public async Task GetBlockHexAsync(string hashOrIndex)
+ {
+ var result = int.TryParse(hashOrIndex, out int index)
+ ? await RpcSendAsync(GetRpcName(), index).ConfigureAwait(false)
+ : await RpcSendAsync(GetRpcName(), hashOrIndex).ConfigureAwait(false);
+ return result.AsString();
+ }
+
+ ///
+ /// Returns the hash of the tallest block in the main chain.
+ ///
+ public async Task GetBlockAsync(string hashOrIndex)
+ {
+ var result = int.TryParse(hashOrIndex, out int index)
+ ? await RpcSendAsync(GetRpcName(), index, true).ConfigureAwait(false)
+ : await RpcSendAsync(GetRpcName(), hashOrIndex, true).ConfigureAwait(false);
+
+ return RpcBlock.FromJson((JObject)result, protocolSettings);
+ }
+
+ ///
+ /// Gets the number of block header in the main chain.
+ ///
+ public async Task GetBlockHeaderCountAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return (uint)result.AsNumber();
+ }
+
+ ///
+ /// Gets the number of blocks in the main chain.
+ ///
+ public async Task GetBlockCountAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return (uint)result.AsNumber();
+ }
+
+ ///
+ /// Returns the hash value of the corresponding block, based on the specified index.
+ ///
+ public async Task GetBlockHashAsync(uint index)
+ {
+ var result = await RpcSendAsync(GetRpcName(), index).ConfigureAwait(false);
+ return result.AsString();
+ }
+
+ ///
+ /// Returns the corresponding block header information according to the specified script hash.
+ ///
+ public async Task GetBlockHeaderHexAsync(string hashOrIndex)
+ {
+ var result = int.TryParse(hashOrIndex, out int index)
+ ? await RpcSendAsync(GetRpcName(), index).ConfigureAwait(false)
+ : await RpcSendAsync(GetRpcName(), hashOrIndex).ConfigureAwait(false);
+ return result.AsString();
+ }
+
+ ///
+ /// Returns the corresponding block header information according to the specified script hash.
+ ///
+ public async Task GetBlockHeaderAsync(string hashOrIndex)
+ {
+ var result = int.TryParse(hashOrIndex, out int index)
+ ? await RpcSendAsync(GetRpcName(), index, true).ConfigureAwait(false)
+ : await RpcSendAsync(GetRpcName(), hashOrIndex, true).ConfigureAwait(false);
+
+ return RpcBlockHeader.FromJson((JObject)result, protocolSettings);
+ }
+
+ ///
+ /// Queries contract information, according to the contract script hash.
+ ///
+ public async Task GetContractStateAsync(string hash)
+ {
+ var result = await RpcSendAsync(GetRpcName(), hash).ConfigureAwait(false);
+ return ContractStateFromJson((JObject)result);
+ }
+
+ ///
+ /// Queries contract information, according to the contract id.
+ ///
+ public async Task GetContractStateAsync(int id)
+ {
+ var result = await RpcSendAsync(GetRpcName(), id).ConfigureAwait(false);
+ return ContractStateFromJson((JObject)result);
+ }
+
+ public static ContractState ContractStateFromJson(JObject json)
+ {
+ return new ContractState
+ {
+ Id = (int)json["id"].AsNumber(),
+ UpdateCounter = (ushort)(json["updatecounter"]?.AsNumber() ?? 0),
+ Hash = UInt160.Parse(json["hash"].AsString()),
+ Nef = RpcNefFile.FromJson((JObject)json["nef"]),
+ Manifest = ContractManifest.FromJson((JObject)json["manifest"])
+ };
+ }
+
+ ///
+ /// Get all native contracts.
+ ///
+ public async Task GetNativeContractsAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return ((JArray)result).Select(p => ContractStateFromJson((JObject)p)).ToArray();
+ }
+
+ ///
+ /// Obtains the list of unconfirmed transactions in memory.
+ ///
+ public async Task GetRawMempoolAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return ((JArray)result).Select(p => p.AsString()).ToArray();
+ }
+
+ ///
+ /// Obtains the list of unconfirmed transactions in memory.
+ /// shouldGetUnverified = true
+ ///
+ public async Task GetRawMempoolBothAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName(), true).ConfigureAwait(false);
+ return RpcRawMemPool.FromJson((JObject)result);
+ }
+
+ ///
+ /// Returns the corresponding transaction information, based on the specified hash value.
+ ///
+ public async Task GetRawTransactionHexAsync(string txHash)
+ {
+ var result = await RpcSendAsync(GetRpcName(), txHash).ConfigureAwait(false);
+ return result.AsString();
+ }
+
+ ///
+ /// Returns the corresponding transaction information, based on the specified hash value.
+ /// verbose = true
+ ///
+ public async Task GetRawTransactionAsync(string txHash)
+ {
+ var result = await RpcSendAsync(GetRpcName(), txHash, true).ConfigureAwait(false);
+ return RpcTransaction.FromJson((JObject)result, protocolSettings);
+ }
+
+ ///
+ /// Calculate network fee
+ ///
+ /// Transaction
+ /// NetworkFee
+ public async Task CalculateNetworkFeeAsync(Transaction tx)
+ {
+ var json = await RpcSendAsync(GetRpcName(), Convert.ToBase64String(tx.ToArray()))
+ .ConfigureAwait(false);
+ return (long)json["networkfee"].AsNumber();
+ }
+
+ ///
+ /// Returns the stored value, according to the contract script hash (or Id) and the stored key.
+ ///
+ public async Task GetStorageAsync(string scriptHashOrId, string key)
+ {
+ var result = int.TryParse(scriptHashOrId, out int id)
+ ? await RpcSendAsync(GetRpcName(), id, key).ConfigureAwait(false)
+ : await RpcSendAsync(GetRpcName(), scriptHashOrId, key).ConfigureAwait(false);
+ return result.AsString();
+ }
+
+ ///
+ /// Returns the block index in which the transaction is found.
+ ///
+ public async Task GetTransactionHeightAsync(string txHash)
+ {
+ var result = await RpcSendAsync(GetRpcName(), txHash).ConfigureAwait(false);
+ return uint.Parse(result.AsString());
+ }
+
+ ///
+ /// Returns the next NEO consensus nodes information and voting status.
+ ///
+ public async Task GetNextBlockValidatorsAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return ((JArray)result).Select(p => RpcValidator.FromJson((JObject)p)).ToArray();
+ }
+
+ ///
+ /// Returns the current NEO committee members.
+ ///
+ public async Task GetCommitteeAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return ((JArray)result).Select(p => p.AsString()).ToArray();
+ }
+
+ #endregion Blockchain
+
+ #region Node
+
+ ///
+ /// Gets the current number of connections for the node.
+ ///
+ public async Task GetConnectionCountAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return (int)result.AsNumber();
+ }
+
+ ///
+ /// Gets the list of nodes that the node is currently connected/disconnected from.
+ ///
+ public async Task GetPeersAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return RpcPeers.FromJson((JObject)result);
+ }
+
+ ///
+ /// Returns the version information about the queried node.
+ ///
+ public async Task GetVersionAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return RpcVersion.FromJson((JObject)result);
+ }
+
+ ///
+ /// Broadcasts a serialized transaction over the NEO network.
+ ///
+ public async Task SendRawTransactionAsync(byte[] rawTransaction)
+ {
+ var result = await RpcSendAsync(GetRpcName(), Convert.ToBase64String(rawTransaction)).ConfigureAwait(false);
+ return UInt256.Parse(result["hash"].AsString());
+ }
+
+ ///
+ /// Broadcasts a transaction over the NEO network.
+ ///
+ public Task SendRawTransactionAsync(Transaction transaction)
+ {
+ return SendRawTransactionAsync(transaction.ToArray());
+ }
+
+ ///
+ /// Broadcasts a serialized block over the NEO network.
+ ///
+ public async Task SubmitBlockAsync(byte[] block)
+ {
+ var result = await RpcSendAsync(GetRpcName(), Convert.ToBase64String(block)).ConfigureAwait(false);
+ return UInt256.Parse(result["hash"].AsString());
+ }
+
+ #endregion Node
+
+ #region SmartContract
+
+ ///
+ /// Returns the result after calling a smart contract at scripthash with the given operation and parameters.
+ /// This RPC call does not affect the blockchain in any way.
+ ///
+ public async Task InvokeFunctionAsync(string scriptHash, string operation, RpcStack[] stacks, params Signer[] signer)
+ {
+ List parameters = new() { scriptHash.AsScriptHash(), operation, stacks.Select(p => p.ToJson()).ToArray() };
+ if (signer.Length > 0)
+ {
+ parameters.Add(signer.Select(p => p.ToJson()).ToArray());
+ }
+ var result = await RpcSendAsync(GetRpcName(), parameters.ToArray()).ConfigureAwait(false);
+ return RpcInvokeResult.FromJson((JObject)result);
+ }
+
+ ///
+ /// Returns the result after passing a script through the VM.
+ /// This RPC call does not affect the blockchain in any way.
+ ///
+ public async Task InvokeScriptAsync(ReadOnlyMemory script, params Signer[] signers)
+ {
+ List parameters = new() { Convert.ToBase64String(script.Span) };
+ if (signers.Length > 0)
+ {
+ parameters.Add(signers.Select(p => p.ToJson()).ToArray());
+ }
+ var result = await RpcSendAsync(GetRpcName(), parameters.ToArray()).ConfigureAwait(false);
+ return RpcInvokeResult.FromJson((JObject)result);
+ }
+
+ public async Task GetUnclaimedGasAsync(string address)
+ {
+ var result = await RpcSendAsync(GetRpcName(), address.AsScriptHash()).ConfigureAwait(false);
+ return RpcUnclaimedGas.FromJson((JObject)result);
+ }
+
+
+ public async IAsyncEnumerable TraverseIteratorAsync(string sessionId, string id)
+ {
+ const int count = 100;
+ while (true)
+ {
+ var result = await RpcSendAsync(GetRpcName(), sessionId, id, count).ConfigureAwait(false);
+ var array = (JArray)result;
+ foreach (JObject jObject in array)
+ {
+ yield return jObject;
+ }
+ if (array.Count < count) break;
+ }
+ }
+
+ ///
+ /// Returns limit results from Iterator.
+ /// This RPC call does not affect the blockchain in any way.
+ ///
+ ///
+ ///
+ ///
+ ///
+ public async IAsyncEnumerable TraverseIteratorAsync(string sessionId, string id, int count)
+ {
+ var result = await RpcSendAsync(GetRpcName(), sessionId, id, count).ConfigureAwait(false);
+ if (result is JArray { Count: > 0 } array)
+ {
+ foreach (JObject jObject in array)
+ {
+ yield return jObject;
+ }
+ }
+ }
+
+ ///
+ /// Terminate specified Iterator session.
+ /// This RPC call does not affect the blockchain in any way.
+ ///
+ public async Task TerminateSessionAsync(string sessionId)
+ {
+ var result = await RpcSendAsync(GetRpcName(), sessionId).ConfigureAwait(false);
+ return result.GetBoolean();
+ }
+
+ #endregion SmartContract
+
+ #region Utilities
+
+ ///
+ /// Returns a list of plugins loaded by the node.
+ ///
+ public async Task ListPluginsAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return ((JArray)result).Select(p => RpcPlugin.FromJson((JObject)p)).ToArray();
+ }
+
+ ///
+ /// Verifies that the address is a correct NEO address.
+ ///
+ public async Task ValidateAddressAsync(string address)
+ {
+ var result = await RpcSendAsync(GetRpcName(), address).ConfigureAwait(false);
+ return RpcValidateAddressResult.FromJson((JObject)result);
+ }
+
+ #endregion Utilities
+
+ #region Wallet
+
+ ///
+ /// Close the wallet opened by RPC.
+ ///
+ public async Task CloseWalletAsync()
+ {
+ var result = await RpcSendAsync(GetRpcName()).ConfigureAwait(false);
+ return result.AsBoolean();
+ }
+
+ ///