neo-devpack-solidity 0.22.0

Production-focused Solidity-to-NeoVM compilation system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

using System.Numerics;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Neo.Sol.Runtime;
using Neo.Sol.Runtime.ABI;
using Neo.Sol.Runtime.Crypto;
using Neo.Sol.Runtime.Exceptions;

namespace Neo.Sol.Runtime.Tests;

[TestClass]
public class ComprehensiveRuntimeTests
{
    [TestMethod]
    public void Runtime_CanBeConstructedOutsideNeoVmHost()
    {
        using var runtime = new EvmRuntime(Neo.UInt160.Parse("0x1234567890123456789012345678901234567890"));

        Assert.IsNotNull(runtime);
        Assert.IsNotNull(runtime.Memory);
        Assert.IsNotNull(runtime.Storage);
        Assert.IsNotNull(runtime.Events);
        Assert.IsNotNull(runtime.Context);
        Assert.AreEqual(0u, runtime.Events.GetEventCount());
    }

    [TestMethod]
    public void Runtime_GetStats_IsAvailableOnFreshRuntime()
    {
        using var runtime = new EvmRuntime(Neo.UInt160.Parse("0x1111111111111111111111111111111111111111"));

        runtime.Memory.Store(0, new BigInteger(42));
        var stats = runtime.GetStats();

        Assert.IsNotNull(stats);
        Assert.IsTrue(stats.MemoryStats.TotalSize > 0);
        Assert.AreEqual(0ul, stats.StorageStats.StorageReads);
        Assert.AreEqual(0ul, stats.StorageStats.StorageWrites);
        Assert.IsTrue(stats.GasUsed > 0);
    }

    [TestMethod]
    public void Runtime_CryptoHelpers_ReturnExpectedShapes()
    {
        using var runtime = new EvmRuntime(Neo.UInt160.Parse("0x2222222222222222222222222222222222222222"));
        var publicKey = Enumerable.Range(0, 64).Select(i => (byte)i).ToArray();

        var keccak = runtime.Keccak256("hello"u8.ToArray());
        var sha = runtime.Sha256("hello"u8.ToArray());
        var address = runtime.PublicKeyToAddress(publicKey);

        CollectionAssert.AreEqual(keccak, runtime.Keccak256("hello"u8.ToArray()));
        CollectionAssert.AreEqual(sha, runtime.Sha256("hello"u8.ToArray()));
        Assert.AreEqual(32, keccak.Length);
        Assert.AreEqual(32, sha.Length);
        Assert.AreEqual(20, address.Length);
    }

    [TestMethod]
    public void AbiEncoder_RoundTripsCoreShapes()
    {
        var encodedCall = AbiEncoder.EncodeCall(
            "transfer(address,uint256)",
            Neo.UInt160.Parse("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
            new BigInteger(123)
        );
        var encodedUint = AbiEncoder.EncodeUint256(new BigInteger(123));
        var encodedInt = AbiEncoder.EncodeInt256(new BigInteger(-9));
        var encodedAddress = AbiEncoder.EncodeAddress(
            Neo.UInt160.Parse("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
        );

        Assert.AreEqual(4 + 64, encodedCall.Length);
        Assert.AreEqual(new BigInteger(123), AbiDecoder.DecodeUint256(encodedUint));
        Assert.AreEqual(new BigInteger(-9), AbiDecoder.DecodeInt256(encodedInt));
        Assert.AreEqual(
            Neo.UInt160.Parse("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
            AbiDecoder.DecodeAddress(encodedAddress)
        );
    }

    [TestMethod]
    public void ExceptionHandler_ExecuteAndRecover_WorkConsistently()
    {
        using var handler = new EvmExceptionHandler();

        var success = handler.Execute(() => 7 * 6);
        var recovered = handler.TryRecover<int>(() => throw new InvalidOperationException("boom"), -1);
        var failure = handler.Execute<int>(() => throw new ArgumentException("bad"));

        Assert.IsTrue(success.IsSuccess);
        Assert.AreEqual(42, success.Value);
        Assert.AreEqual(-1, recovered);
        Assert.IsFalse(failure.IsSuccess);
        Assert.IsNotNull(failure.Error);
        Assert.AreEqual("ArgumentException", failure.Error.Type);
    }

    [TestMethod]
    public void StorageSlotHelpers_AreDeterministic()
    {
        var mappingSlot1 = Neo.Sol.Runtime.Storage.StorageManager.CalculateMappingElementSlot(
            BigInteger.Zero,
            new BigInteger(123)
        );
        var mappingSlot2 = Neo.Sol.Runtime.Storage.StorageManager.CalculateMappingElementSlot(
            BigInteger.Zero,
            new BigInteger(123)
        );
        var arraySlot1 = Neo.Sol.Runtime.Storage.StorageManager.CalculateArrayElementSlot(
            new BigInteger(5),
            BigInteger.One
        );
        var arraySlot2 = Neo.Sol.Runtime.Storage.StorageManager.CalculateArrayElementSlot(
            new BigInteger(5),
            BigInteger.One
        );

        Assert.AreEqual(mappingSlot1, mappingSlot2);
        Assert.AreEqual(arraySlot1, arraySlot2);
        Assert.AreNotEqual(mappingSlot1, arraySlot1);
    }
}