diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/EvmStackBenchmarks.cs b/src/Nethermind/Nethermind.Evm.Benchmark/EvmStackBenchmarks.cs
index 2825bb7e5a8..1c3c0599562 100644
--- a/src/Nethermind/Nethermind.Evm.Benchmark/EvmStackBenchmarks.cs
+++ b/src/Nethermind/Nethermind.Evm.Benchmark/EvmStackBenchmarks.cs
@@ -47,27 +47,6 @@ public UInt256 Uint256(UInt256 v)
             return value;
         }
 
-        [Benchmark(OperationsPerInvoke = 4)]
-        [ArgumentsSource(nameof(ValueSource))]
-        public Int256.Int256 Int256(UInt256 v)
-        {
-            EvmStack<VirtualMachine.NotTracing> stack = new(_stack.AsSpan(), 0, NullTxTracer.Instance);
-
-            stack.PushSignedInt256(new Int256.Int256(v));
-            stack.PopSignedInt256(out Int256.Int256 value);
-
-            stack.PushSignedInt256(value);
-            stack.PopSignedInt256(out value);
-
-            stack.PushSignedInt256(value);
-            stack.PopSignedInt256(out value);
-
-            stack.PushSignedInt256(value);
-            stack.PopSignedInt256(out value);
-
-            return value;
-        }
-
         [Benchmark(OperationsPerInvoke = 4)]
         public byte Byte()
         {
diff --git a/src/Nethermind/Nethermind.Evm/EvmStack.cs b/src/Nethermind/Nethermind.Evm/EvmStack.cs
index 48dc9ae49a2..b59af410489 100644
--- a/src/Nethermind/Nethermind.Evm/EvmStack.cs
+++ b/src/Nethermind/Nethermind.Evm/EvmStack.cs
@@ -218,13 +218,6 @@ public void PopLimbo()
         }
     }
 
-    public void PopSignedInt256(out Int256.Int256 result)
-    {
-        // tail call into UInt256
-        Unsafe.SkipInit(out result);
-        PopUInt256(out Unsafe.As<Int256.Int256, UInt256>(ref result));
-    }
-
     /// <summary>
     /// Pops an Uint256 written in big endian.
     /// </summary>
@@ -233,9 +226,11 @@ public void PopSignedInt256(out Int256.Int256 result)
     /// All it does is <see cref="Unsafe.ReadUnaligned{T}(ref byte)"/> and then reverse endianness if needed. Then it creates <paramref name="result"/>.
     /// </remarks>
     /// <param name="result">The returned value.</param>
-    public void PopUInt256(out UInt256 result)
+    public bool PopUInt256(out UInt256 result)
     {
+        Unsafe.SkipInit(out result);
         ref byte bytes = ref PopBytesByRef();
+        if (Unsafe.IsNullRef(ref bytes)) return false;
 
         if (Avx2.IsSupported)
         {
@@ -271,6 +266,8 @@ public void PopUInt256(out UInt256 result)
 
             result = new UInt256(u0, u1, u2, u3);
         }
+
+        return true;
     }
 
     public readonly bool PeekUInt256IsZero()
@@ -300,7 +297,7 @@ public Address PopAddress()
     {
         if (Head-- == 0)
         {
-            EvmStack.ThrowEvmStackUnderflowException();
+            return null;
         }
 
         return new Address(_bytes.Slice(Head * WordSize + WordSize - AddressSize, AddressSize).ToArray());
@@ -310,7 +307,7 @@ public ref byte PopBytesByRef()
     {
         if (Head-- == 0)
         {
-            EvmStack.ThrowEvmStackUnderflowException();
+            return ref Unsafe.NullRef<byte>();
         }
 
         return ref _bytes[Head * WordSize];
@@ -356,9 +353,9 @@ public void PushLeftPaddedBytes(Span<byte> value, int paddingLength)
         }
     }
 
-    public void Dup(in int depth)
+    public bool Dup(in int depth)
     {
-        EnsureDepth(depth);
+        if (!EnsureDepth(depth)) return false;
 
         ref byte bytes = ref MemoryMarshal.GetReference(_bytes);
 
@@ -376,19 +373,23 @@ public void Dup(in int depth)
         {
             EvmStack.ThrowEvmStackOverflowException();
         }
+
+        return true;
     }
 
-    public readonly void EnsureDepth(int depth)
+    public readonly bool EnsureDepth(int depth)
     {
         if (Head < depth)
         {
-            EvmStack.ThrowEvmStackUnderflowException();
+            return false;
         }
+
+        return true;
     }
 
-    public readonly void Swap(int depth)
+    public readonly bool Swap(int depth)
     {
-        EnsureDepth(depth);
+        if (!EnsureDepth(depth)) return false;
 
         ref byte bytes = ref MemoryMarshal.GetReference(_bytes);
 
@@ -403,6 +404,8 @@ public readonly void Swap(int depth)
         {
             Trace(depth);
         }
+
+        return true;
     }
 
     private readonly void Trace(int depth)
diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs
index c168656d7ba..3ddd12fbc2d 100644
--- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs
+++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs
@@ -811,8 +811,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out b);
-                        stack.PopUInt256(out a);
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
                         UInt256.Add(in a, in b, out result);
                         stack.PushUInt256(result);
 
@@ -822,8 +822,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Low;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         UInt256.Multiply(in a, in b, out result);
                         stack.PushUInt256(in result);
                         break;
@@ -832,8 +832,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         UInt256.Subtract(in a, in b, out result);
 
                         stack.PushUInt256(in result);
@@ -843,8 +843,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Low;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         if (b.IsZero)
                         {
                             stack.PushZero();
@@ -861,8 +861,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Low;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         if (b.IsZero)
                         {
                             stack.PushZero();
@@ -884,8 +884,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Low;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         UInt256.Mod(in a, in b, out result);
                         stack.PushUInt256(in result);
                         break;
@@ -894,8 +894,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Low;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         if (b.IsZeroOrOne)
                         {
                             stack.PushZero();
@@ -913,9 +913,9 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Mid;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
-                        stack.PopUInt256(out c);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out c)) goto StackUnderflow;
 
                         if (c.IsZero)
                         {
@@ -933,9 +933,9 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Mid;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
-                        stack.PopUInt256(out c);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out c)) goto StackUnderflow;
 
                         if (c.IsZero)
                         {
@@ -955,7 +955,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                         Metrics.ModExpOpcode++;
 
-                        stack.PopUInt256(out a);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
                         bytes = stack.PopWord256();
 
                         int leadingZeros = bytes.LeadingZerosCount();
@@ -990,10 +990,10 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Low;
 
-                        stack.PopUInt256(out a);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
                         if (a >= BigInt32)
                         {
-                            stack.EnsureDepth(1);
+                            if (!stack.EnsureDepth(1)) goto StackUnderflow;
                             break;
                         }
 
@@ -1018,8 +1018,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         if (a < b)
                         {
                             stack.PushOne();
@@ -1035,8 +1035,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         if (a > b)
                         {
                             stack.PushOne();
@@ -1052,8 +1052,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
 
                         if (As<UInt256, Int256>(ref a).CompareTo(As<UInt256, Int256>(ref b)) < 0)
                         {
@@ -1070,8 +1070,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         if (As<UInt256, Int256>(ref a).CompareTo(As<UInt256, Int256>(ref b)) > 0)
                         {
                             stack.PushOne();
@@ -1087,8 +1087,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         if (a.Equals(b))
                         {
                             stack.PushOne();
@@ -1104,7 +1104,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
                         if (a.IsZero)
                         {
                             stack.PushOne();
@@ -1120,8 +1120,13 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        Vector256<byte> aVec = ReadUnaligned<Vector256<byte>>(ref stack.PopBytesByRef());
-                        Vector256<byte> bVec = ReadUnaligned<Vector256<byte>>(ref stack.PopBytesByRef());
+                        ref byte bytesRef = ref stack.PopBytesByRef();
+                        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
+                        Vector256<byte> aVec = ReadUnaligned<Vector256<byte>>(ref bytesRef);
+
+                        bytesRef = ref stack.PopBytesByRef();
+                        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
+                        Vector256<byte> bVec = ReadUnaligned<Vector256<byte>>(ref bytesRef);
 
                         WriteUnaligned(ref stack.PushBytesRef(), Vector256.BitwiseAnd(aVec, bVec));
                         break;
@@ -1130,8 +1135,13 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        Vector256<byte> aVec = ReadUnaligned<Vector256<byte>>(ref stack.PopBytesByRef());
-                        Vector256<byte> bVec = ReadUnaligned<Vector256<byte>>(ref stack.PopBytesByRef());
+                        ref byte bytesRef = ref stack.PopBytesByRef();
+                        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
+                        Vector256<byte> aVec = ReadUnaligned<Vector256<byte>>(ref bytesRef);
+
+                        bytesRef = ref stack.PopBytesByRef();
+                        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
+                        Vector256<byte> bVec = ReadUnaligned<Vector256<byte>>(ref bytesRef);
 
                         WriteUnaligned(ref stack.PushBytesRef(), Vector256.BitwiseOr(aVec, bVec));
                         break;
@@ -1140,8 +1150,13 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        Vector256<byte> aVec = ReadUnaligned<Vector256<byte>>(ref stack.PopBytesByRef());
-                        Vector256<byte> bVec = ReadUnaligned<Vector256<byte>>(ref stack.PopBytesByRef());
+                        ref byte bytesRef = ref stack.PopBytesByRef();
+                        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
+                        Vector256<byte> aVec = ReadUnaligned<Vector256<byte>>(ref bytesRef);
+
+                        bytesRef = ref stack.PopBytesByRef();
+                        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
+                        Vector256<byte> bVec = ReadUnaligned<Vector256<byte>>(ref bytesRef);
 
                         WriteUnaligned(ref stack.PushBytesRef(), Vector256.Xor(aVec, bVec));
                         break;
@@ -1150,7 +1165,10 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        Vector256<byte> negVec = Vector256.OnesComplement(ReadUnaligned<Vector256<byte>>(ref stack.PopBytesByRef()));
+                        ref byte bytesRef = ref stack.PopBytesByRef();
+                        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
+
+                        Vector256<byte> negVec = Vector256.OnesComplement(ReadUnaligned<Vector256<byte>>(ref bytesRef));
 
                         WriteUnaligned(ref stack.PushBytesRef(), negVec);
                         break;
@@ -1159,7 +1177,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
                         bytes = stack.PopWord256();
 
                         if (a >= BigInt32)
@@ -1182,8 +1200,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     }
                 case Instruction.KECCAK256:
                     {
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         gasAvailable -= GasCostOf.Sha3 + GasCostOf.Sha3Word * EvmPooledMemory.Div32Ceiling(in b);
 
                         if (!UpdateMemoryCost(vmState, ref gasAvailable, in a, b)) goto OutOfGas;
@@ -1204,6 +1222,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                         gasAvailable -= spec.GetBalanceCost();
 
                         Address address = stack.PopAddress();
+                        if (address is null) goto StackUnderflow;
+
                         if (!ChargeAccountAccessGas(ref gasAvailable, vmState, address, spec)) goto OutOfGas;
 
                         result = _state.GetBalance(address);
@@ -1236,7 +1256,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         stack.PushBytes(env.InputData.SliceWithZeroPadding(result, 32));
                         break;
                     }
@@ -1250,9 +1270,9 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     }
                 case Instruction.CALLDATACOPY:
                     {
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         gasAvailable -= GasCostOf.VeryLow + GasCostOf.Memory * EvmPooledMemory.Div32Ceiling(in result);
 
                         if (!result.IsZero)
@@ -1279,9 +1299,9 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     }
                 case Instruction.CODECOPY:
                     {
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         gasAvailable -= GasCostOf.VeryLow + GasCostOf.Memory * EvmPooledMemory.Div32Ceiling(in result);
 
                         if (!result.IsZero)
@@ -1308,6 +1328,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                         gasAvailable -= spec.GetExtCodeCost();
 
                         Address address = stack.PopAddress();
+                        if (address is null) goto StackUnderflow;
+
                         if (!ChargeAccountAccessGas(ref gasAvailable, vmState, address, spec)) goto OutOfGas;
 
                         if (typeof(TTracingInstructions) != typeof(IsTracing) && programCounter < code.Length)
@@ -1365,9 +1387,10 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                 case Instruction.EXTCODECOPY:
                     {
                         Address address = stack.PopAddress();
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
-                        stack.PopUInt256(out result);
+                        if (address is null) goto StackUnderflow;
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
 
                         gasAvailable -= spec.GetExtCodeCost() + GasCostOf.Memory * EvmPooledMemory.Div32Ceiling(in result);
 
@@ -1402,9 +1425,9 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         if (!spec.ReturnDataOpcodesEnabled) goto InvalidInstruction;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         gasAvailable -= GasCostOf.VeryLow + GasCostOf.Memory * EvmPooledMemory.Div32Ceiling(in result);
 
                         if (UInt256.AddOverflow(result, b, out c) || c > _returnDataBuffer.Length)
@@ -1432,7 +1455,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                         gasAvailable -= GasCostOf.BlockHash;
 
-                        stack.PopUInt256(out a);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
                         long number = a > long.MaxValue ? long.MaxValue : (long)a;
                         Hash256 blockHash = _blockhashProvider.GetBlockhash(blkCtx.Header, number);
                         stack.PushBytes(blockHash != null ? blockHash.Bytes : BytesZero32);
@@ -1528,7 +1551,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                         gasAvailable -= GasCostOf.BlobHash;
 
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
 
                         if (txCtx.BlobVersionedHashes is not null && result < txCtx.BlobVersionedHashes.Length)
                         {
@@ -1561,7 +1584,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         if (!UpdateMemoryCost(vmState, ref gasAvailable, in result, in BigInt32)) goto OutOfGas;
                         bytes = vmState.Memory.LoadSpan(in result);
                         if (typeof(TTracingInstructions) == typeof(IsTracing)) _txTracer.ReportMemoryChange(result, bytes);
@@ -1573,7 +1596,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
 
                         bytes = stack.PopWord256();
                         if (!UpdateMemoryCost(vmState, ref gasAvailable, in result, in BigInt32)) goto OutOfGas;
@@ -1586,7 +1609,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         byte data = stack.PopByte();
                         if (!UpdateMemoryCost(vmState, ref gasAvailable, in result, UInt256.One)) goto OutOfGas;
                         vmState.Memory.SaveByte(in result, data);
@@ -1599,7 +1622,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                         Metrics.SloadOpcode++;
                         gasAvailable -= spec.GetSLoadCost();
 
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         storageCell = new(env.ExecutingAccount, result);
                         if (!ChargeStorageAccessGas(
                             ref gasAvailable,
@@ -1624,8 +1647,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                         if (vmState.IsStatic) goto StaticCallViolation;
 
-                        if (!InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingStorage>(vmState, ref stack, ref gasAvailable, spec))
-                            goto OutOfGas;
+                        exceptionType = InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingStorage>(vmState, ref stack, ref gasAvailable, spec);
+                        if (exceptionType != EvmExceptionType.None) goto ReturnFailure;
 
                         break;
                     }
@@ -1633,7 +1656,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.Mid;
 
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         if (!Jump(result, ref programCounter, in env)) goto InvalidJumpDestination;
                         break;
                     }
@@ -1641,7 +1664,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.High;
 
-                        stack.PopUInt256(out result);
+                        if (!stack.PopUInt256(out result)) goto StackUnderflow;
                         bytes = stack.PopWord256();
                         if (!bytes.SequenceEqual(BytesZero32))
                         {
@@ -1766,7 +1789,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.Dup(instruction - Instruction.DUP1 + 1);
+                        if (!stack.Dup(instruction - Instruction.DUP1 + 1)) goto StackUnderflow;
                         break;
                     }
                 case Instruction.SWAP1:
@@ -1788,7 +1811,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.Swap(instruction - Instruction.SWAP1 + 2);
+                        if (!stack.Swap(instruction - Instruction.SWAP1 + 2)) goto StackUnderflow;
                         break;
                     }
                 case Instruction.LOG0:
@@ -1799,7 +1822,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         if (vmState.IsStatic) goto StaticCallViolation;
 
-                        if (!InstructionLog(vmState, ref stack, ref gasAvailable, instruction)) goto OutOfGas;
+                        exceptionType = InstructionLog(vmState, ref stack, ref gasAvailable, instruction);
+                        if (exceptionType != EvmExceptionType.None) goto ReturnFailure;
                         break;
                     }
                 case Instruction.CREATE:
@@ -1810,16 +1834,17 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                         if (vmState.IsStatic) goto StaticCallViolation;
 
-                        (bool outOfGas, returnData) = InstructionCreate(vmState, ref stack, ref gasAvailable, spec, instruction);
+                        (exceptionType, returnData) = InstructionCreate(vmState, ref stack, ref gasAvailable, spec, instruction);
+                        if (exceptionType != EvmExceptionType.None) goto ReturnFailure;
 
-                        if (outOfGas) goto OutOfGas;
                         if (returnData is null) break;
 
                         goto DataReturnNoTrace;
                     }
                 case Instruction.RETURN:
                     {
-                        if (!InstructionReturn(vmState, ref stack, ref gasAvailable, out returnData)) goto OutOfGas;
+                        exceptionType = InstructionReturn(vmState, ref stack, ref gasAvailable, out returnData);
+                        if (exceptionType != EvmExceptionType.None) goto ReturnFailure;
 
                         goto DataReturn;
                     }
@@ -1829,10 +1854,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                 case Instruction.STATICCALL:
                     {
                         exceptionType = InstructionCall<TTracingInstructions, TTracingRefunds>(vmState, ref stack, ref gasAvailable, spec, instruction, out returnData);
-                        if (exceptionType != EvmExceptionType.None)
-                        {
-                            goto ReturnFailure;
-                        }
+                        if (exceptionType != EvmExceptionType.None) goto ReturnFailure;
+
                         if (returnData is null)
                         {
                             break;
@@ -1844,7 +1867,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                     {
                         if (!spec.RevertOpcodeEnabled) goto InvalidInstruction;
 
-                        if (!InstructionRevert(vmState, ref stack, ref gasAvailable, out returnData)) goto OutOfGas;
+                        exceptionType = InstructionRevert(vmState, ref stack, ref gasAvailable, out returnData);
+                        if (exceptionType != EvmExceptionType.None) goto ReturnFailure;
 
                         isRevert = true;
                         goto DataReturn;
@@ -1864,7 +1888,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                             gasAvailable -= GasCostOf.SelfDestructEip150;
                         }
 
-                        if (!InstructionSelfDestruct(vmState, ref stack, ref gasAvailable, spec)) goto OutOfGas;
+                        exceptionType = InstructionSelfDestruct(vmState, ref stack, ref gasAvailable, spec);
+                        if (exceptionType != EvmExceptionType.None) goto ReturnFailure;
 
                         goto EmptyReturn;
                     }
@@ -1874,7 +1899,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
                         if (a >= 256UL)
                         {
                             stack.PopLimbo();
@@ -1882,7 +1907,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                         }
                         else
                         {
-                            stack.PopUInt256(out b);
+                            if (!stack.PopUInt256(out b)) goto StackUnderflow;
                             result = b << (int)a.u0;
                             stack.PushUInt256(in result);
                         }
@@ -1895,7 +1920,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
                         if (a >= 256)
                         {
                             stack.PopLimbo();
@@ -1903,7 +1928,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                         }
                         else
                         {
-                            stack.PopUInt256(out b);
+                            if (!stack.PopUInt256(out b)) goto StackUnderflow;
                             result = b >> (int)a.u0;
                             stack.PushUInt256(in result);
                         }
@@ -1916,8 +1941,8 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                         gasAvailable -= GasCostOf.VeryLow;
 
-                        stack.PopUInt256(out a);
-                        stack.PopUInt256(out b);
+                        if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                        if (!stack.PopUInt256(out b)) goto StackUnderflow;
                         if (a >= BigInt256)
                         {
                             if (As<UInt256, Int256>(ref b).Sign >= 0)
@@ -1944,6 +1969,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                         gasAvailable -= spec.GetExtCodeHashCost();
 
                         Address address = stack.PopAddress();
+                        if (address is null) goto StackUnderflow;
                         if (!ChargeAccountAccessGas(ref gasAvailable, vmState, address, spec)) goto OutOfGas;
 
                         if (!_state.AccountExists(address) || _state.IsDeadAccount(address))
@@ -1964,7 +1990,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                             Metrics.TloadOpcode++;
                             gasAvailable -= GasCostOf.TLoad;
 
-                            stack.PopUInt256(out result);
+                            if (!stack.PopUInt256(out result)) goto StackUnderflow;
                             storageCell = new(env.ExecutingAccount, result);
 
                             byte[] value = _state.GetTransientState(in storageCell);
@@ -1999,7 +2025,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                             gasAvailable -= GasCostOf.TStore;
 
-                            stack.PopUInt256(out result);
+                            if (!stack.PopUInt256(out result)) goto StackUnderflow;
                             storageCell = new(env.ExecutingAccount, result);
                             bytes = stack.PopWord256();
 
@@ -2035,9 +2061,9 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
                         {
                             Metrics.MCopyOpcode++;
 
-                            stack.PopUInt256(out a);
-                            stack.PopUInt256(out b);
-                            stack.PopUInt256(out c);
+                            if (!stack.PopUInt256(out a)) goto StackUnderflow;
+                            if (!stack.PopUInt256(out b)) goto StackUnderflow;
+                            if (!stack.PopUInt256(out c)) goto StackUnderflow;
 
                             gasAvailable -= GasCostOf.VeryLow + GasCostOf.VeryLow * EvmPooledMemory.Div32Ceiling(c);
                             if (!UpdateMemoryCost(vmState, ref gasAvailable, UInt256.Max(b, a), c)) goto OutOfGas;
@@ -2060,7 +2086,7 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
 
                             vmState.ReturnStack[vmState.ReturnStackHead++] = programCounter;
 
-                            stack.PopUInt256(out UInt256 jumpDest);
+                            if (!stack.PopUInt256(out UInt256 jumpDest)) goto StackUnderflow;
                             if (!Jump(jumpDest, ref programCounter, in env, true)) goto InvalidJumpDestination;
                             programCounter++;
 
@@ -2128,6 +2154,9 @@ private CallResult ExecuteCode<TTracingInstructions, TTracingRefunds, TTracingSt
     StackOverflow:
         exceptionType = EvmExceptionType.StackOverflow;
         goto ReturnFailure;
+    StackUnderflow:
+        exceptionType = EvmExceptionType.StackUnderflow;
+        goto ReturnFailure;
     InvalidJumpDestination:
         exceptionType = EvmExceptionType.InvalidJumpDestination;
         goto ReturnFailure;
@@ -2160,8 +2189,9 @@ private EvmExceptionType InstructionCall<TTracingInstructions, TTracingRefunds>(
         if (instruction == Instruction.DELEGATECALL && !spec.DelegateCallEnabled ||
             instruction == Instruction.STATICCALL && !spec.StaticCallEnabled) return EvmExceptionType.BadInstruction;
 
-        stack.PopUInt256(out UInt256 gasLimit);
+        if (!stack.PopUInt256(out UInt256 gasLimit)) return EvmExceptionType.StackUnderflow;
         Address codeSource = stack.PopAddress();
+        if (codeSource is null) return EvmExceptionType.StackUnderflow;
 
         if (!ChargeAccountAccessGas(ref gasAvailable, vmState, codeSource, spec)) return EvmExceptionType.OutOfGas;
 
@@ -2175,15 +2205,15 @@ private EvmExceptionType InstructionCall<TTracingInstructions, TTracingRefunds>(
                 callValue = env.Value;
                 break;
             default:
-                stack.PopUInt256(out callValue);
+                if (!stack.PopUInt256(out callValue)) return EvmExceptionType.StackUnderflow;
                 break;
         }
 
         UInt256 transferValue = instruction == Instruction.DELEGATECALL ? UInt256.Zero : callValue;
-        stack.PopUInt256(out UInt256 dataOffset);
-        stack.PopUInt256(out UInt256 dataLength);
-        stack.PopUInt256(out UInt256 outputOffset);
-        stack.PopUInt256(out UInt256 outputLength);
+        if (!stack.PopUInt256(out UInt256 dataOffset)) return EvmExceptionType.StackUnderflow;
+        if (!stack.PopUInt256(out UInt256 dataLength)) return EvmExceptionType.StackUnderflow;
+        if (!stack.PopUInt256(out UInt256 outputOffset)) return EvmExceptionType.StackUnderflow;
+        if (!stack.PopUInt256(out UInt256 outputLength)) return EvmExceptionType.StackUnderflow;
 
         if (vmState.IsStatic && !transferValue.IsZero && instruction != Instruction.CALLCODE) return EvmExceptionType.StaticCallViolation;
 
@@ -2303,48 +2333,53 @@ private EvmExceptionType InstructionCall<TTracingInstructions, TTracingRefunds>(
     }
 
     [SkipLocalsInit]
-    private static bool InstructionRevert<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, out object returnData)
+    private static EvmExceptionType InstructionRevert<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, out object returnData)
         where TTracing : struct, IIsTracing
     {
-        stack.PopUInt256(out UInt256 position);
-        stack.PopUInt256(out UInt256 length);
+        SkipInit(out returnData);
+
+        if (!stack.PopUInt256(out UInt256 position) ||
+            !stack.PopUInt256(out UInt256 length))
+            return EvmExceptionType.StackUnderflow;
 
         if (!UpdateMemoryCost(vmState, ref gasAvailable, in position, in length))
         {
-            returnData = null;
-            return false;
+            return EvmExceptionType.OutOfGas;
         }
 
         returnData = vmState.Memory.Load(in position, in length).ToArray();
-        return true;
+        return EvmExceptionType.None;
     }
 
     [SkipLocalsInit]
-    private static bool InstructionReturn<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, out object returnData)
+    private static EvmExceptionType InstructionReturn<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, out object returnData)
         where TTracing : struct, IIsTracing
     {
-        stack.PopUInt256(out UInt256 position);
-        stack.PopUInt256(out UInt256 length);
+        SkipInit(out returnData);
+
+        if (!stack.PopUInt256(out UInt256 position) ||
+            !stack.PopUInt256(out UInt256 length))
+            return EvmExceptionType.StackUnderflow;
 
         if (!UpdateMemoryCost(vmState, ref gasAvailable, in position, in length))
         {
-            returnData = null;
-            return false;
+            return EvmExceptionType.OutOfGas;
         }
 
         returnData = vmState.Memory.Load(in position, in length).ToArray();
 
-        return true;
+        return EvmExceptionType.None;
     }
 
     [SkipLocalsInit]
-    private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, IReleaseSpec spec)
+    private EvmExceptionType InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, IReleaseSpec spec)
         where TTracing : struct, IIsTracing
     {
         Metrics.SelfDestructs++;
 
         Address inheritor = stack.PopAddress();
-        if (!ChargeAccountAccessGas(ref gasAvailable, vmState, inheritor, spec, false)) return false;
+        if (inheritor is null) return EvmExceptionType.StackUnderflow;
+        if (!ChargeAccountAccessGas(ref gasAvailable, vmState, inheritor, spec, false)) return EvmExceptionType.OutOfGas;
 
         Address executingAccount = vmState.Env.ExecutingAccount;
         bool createInSameTx = vmState.CreateList.Contains(executingAccount);
@@ -2355,13 +2390,13 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
         if (_txTracer.IsTracingActions) _txTracer.ReportSelfDestruct(executingAccount, result, inheritor);
         if (spec.ClearEmptyAccountWhenTouched && !result.IsZero && _state.IsDeadAccount(inheritor))
         {
-            if (!UpdateGas(GasCostOf.NewAccount, ref gasAvailable)) return false;
+            if (!UpdateGas(GasCostOf.NewAccount, ref gasAvailable)) return EvmExceptionType.OutOfGas;
         }
 
         bool inheritorAccountExists = _state.AccountExists(inheritor);
         if (!spec.ClearEmptyAccountWhenTouched && !inheritorAccountExists && spec.UseShanghaiDDosProtection)
         {
-            if (!UpdateGas(GasCostOf.NewAccount, ref gasAvailable)) return false;
+            if (!UpdateGas(GasCostOf.NewAccount, ref gasAvailable)) return EvmExceptionType.OutOfGas;
         }
 
         if (!inheritorAccountExists)
@@ -2374,14 +2409,14 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
         }
 
         if (spec.SelfdestructOnlyOnSameTransaction && !createInSameTx && inheritor.Equals(executingAccount))
-            return true; // dont burn eth when contract is not destroyed per EIP clarification
+            return EvmExceptionType.None; // don't burn eth when contract is not destroyed per EIP clarification
 
         _state.SubtractFromBalance(executingAccount, result, spec);
-        return true;
+        return EvmExceptionType.None;
     }
 
     [SkipLocalsInit]
-    private (bool outOfGas, EvmState? callState) InstructionCreate<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, IReleaseSpec spec, Instruction instruction)
+    private (EvmExceptionType exceptionType, EvmState? callState) InstructionCreate<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, IReleaseSpec spec, Instruction instruction)
         where TTracing : struct, IIsTracing
     {
         ref readonly ExecutionEnvironment env = ref vmState.Env;
@@ -2392,9 +2427,11 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
             _state.CreateAccount(env.ExecutingAccount, UInt256.Zero);
         }
 
-        stack.PopUInt256(out UInt256 value);
-        stack.PopUInt256(out UInt256 memoryPositionOfInitCode);
-        stack.PopUInt256(out UInt256 initCodeLength);
+        if (!stack.PopUInt256(out UInt256 value) ||
+            !stack.PopUInt256(out UInt256 memoryPositionOfInitCode) ||
+            !stack.PopUInt256(out UInt256 initCodeLength))
+            return (EvmExceptionType.StackUnderflow, null);
+
         Span<byte> salt = default;
         if (instruction == Instruction.CREATE2)
         {
@@ -2404,7 +2441,7 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
         //EIP-3860
         if (spec.IsEip3860Enabled)
         {
-            if (initCodeLength > spec.MaxInitCodeSize) return (outOfGas: true, null);
+            if (initCodeLength > spec.MaxInitCodeSize) return (EvmExceptionType.OutOfGas, null);
         }
 
         long gasCost = GasCostOf.Create +
@@ -2413,9 +2450,9 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
                            ? GasCostOf.Sha3Word * EvmPooledMemory.Div32Ceiling(initCodeLength)
                            : 0);
 
-        if (!UpdateGas(gasCost, ref gasAvailable)) return (outOfGas: true, null);
+        if (!UpdateGas(gasCost, ref gasAvailable)) return (EvmExceptionType.OutOfGas, null);
 
-        if (!UpdateMemoryCost(vmState, ref gasAvailable, in memoryPositionOfInitCode, initCodeLength)) return (outOfGas: true, null);
+        if (!UpdateMemoryCost(vmState, ref gasAvailable, in memoryPositionOfInitCode, initCodeLength)) return (EvmExceptionType.OutOfGas, null);
 
         // TODO: copy pasted from CALL / DELEGATECALL, need to move it outside?
         if (env.CallDepth >= MaxCallDepth) // TODO: fragile ordering / potential vulnerability for different clients
@@ -2423,7 +2460,7 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
             // TODO: need a test for this
             _returnDataBuffer = Array.Empty<byte>();
             stack.PushZero();
-            return (outOfGas: false, null);
+            return (EvmExceptionType.None, null);
         }
 
         Span<byte> initCode = vmState.Memory.LoadSpan(in memoryPositionOfInitCode, initCodeLength);
@@ -2433,7 +2470,7 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
         {
             _returnDataBuffer = Array.Empty<byte>();
             stack.PushZero();
-            return (outOfGas: false, null);
+            return (EvmExceptionType.None, null);
         }
 
         UInt256 accountNonce = _state.GetNonce(env.ExecutingAccount);
@@ -2442,14 +2479,14 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
         {
             _returnDataBuffer = Array.Empty<byte>();
             stack.PushZero();
-            return (outOfGas: false, null);
+            return (EvmExceptionType.None, null);
         }
 
         if (typeof(TTracing) == typeof(IsTracing)) EndInstructionTrace(gasAvailable, vmState.Memory?.Size ?? 0);
         // todo: === below is a new call - refactor / move
 
         long callGas = spec.Use63Over64Rule ? gasAvailable - gasAvailable / 64L : gasAvailable;
-        if (!UpdateGas(callGas, ref gasAvailable)) return (outOfGas: true, null);
+        if (!UpdateGas(callGas, ref gasAvailable)) return (EvmExceptionType.OutOfGas, null);
 
         Address contractAddress = instruction == Instruction.CREATE
             ? ContractAddress.From(env.ExecutingAccount, _state.GetNonce(env.ExecutingAccount))
@@ -2473,7 +2510,7 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
             if (typeof(TLogger) == typeof(IsTracing)) _logger.Trace($"Contract collision at {contractAddress}");
             _returnDataBuffer = Array.Empty<byte>();
             stack.PushZero();
-            return (outOfGas: false, null);
+            return (EvmExceptionType.None, null);
         }
 
         if (accountExists)
@@ -2521,20 +2558,20 @@ private bool InstructionSelfDestruct<TTracing>(EvmState vmState, ref EvmStack<TT
             false,
             accountExists);
 
-        return (outOfGas: false, callState);
+        return (EvmExceptionType.None, callState);
     }
 
     [SkipLocalsInit]
-    private static bool InstructionLog<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, Instruction instruction)
+    private static EvmExceptionType InstructionLog<TTracing>(EvmState vmState, ref EvmStack<TTracing> stack, ref long gasAvailable, Instruction instruction)
         where TTracing : struct, IIsTracing
     {
-        stack.PopUInt256(out UInt256 position);
-        stack.PopUInt256(out UInt256 length);
+        if (!stack.PopUInt256(out UInt256 position)) return EvmExceptionType.StackUnderflow;
+        if (!stack.PopUInt256(out UInt256 length)) return EvmExceptionType.StackUnderflow;
         long topicsCount = instruction - Instruction.LOG0;
-        if (!UpdateMemoryCost(vmState, ref gasAvailable, in position, length)) return false;
+        if (!UpdateMemoryCost(vmState, ref gasAvailable, in position, length)) return EvmExceptionType.OutOfGas;
         if (!UpdateGas(
                 GasCostOf.Log + topicsCount * GasCostOf.LogTopic +
-                (long)length * GasCostOf.LogData, ref gasAvailable)) return false;
+                (long)length * GasCostOf.LogData, ref gasAvailable)) return EvmExceptionType.OutOfGas;
 
         ReadOnlyMemory<byte> data = vmState.Memory.Load(in position, length);
         Hash256[] topics = new Hash256[topicsCount];
@@ -2549,26 +2586,26 @@ private static bool InstructionLog<TTracing>(EvmState vmState, ref EvmStack<TTra
             topics);
         vmState.Logs.Add(logEntry);
 
-        return true;
+        return EvmExceptionType.None;
     }
 
     [SkipLocalsInit]
-    private bool InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingStorage>(EvmState vmState, ref EvmStack<TTracingInstructions> stack, ref long gasAvailable, IReleaseSpec spec)
+    private EvmExceptionType InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingStorage>(EvmState vmState, ref EvmStack<TTracingInstructions> stack, ref long gasAvailable, IReleaseSpec spec)
         where TTracingInstructions : struct, IIsTracing
         where TTracingRefunds : struct, IIsTracing
         where TTracingStorage : struct, IIsTracing
     {
         // fail fast before the first storage read if gas is not enough even for reset
-        if (!spec.UseNetGasMetering && !UpdateGas(spec.GetSStoreResetCost(), ref gasAvailable)) return false;
+        if (!spec.UseNetGasMetering && !UpdateGas(spec.GetSStoreResetCost(), ref gasAvailable)) return EvmExceptionType.OutOfGas;
 
         if (spec.UseNetGasMeteringWithAStipendFix)
         {
             if (typeof(TTracingRefunds) == typeof(IsTracing))
                 _txTracer.ReportExtraGasPressure(GasCostOf.CallStipend - spec.GetNetMeteredSStoreCost() + 1);
-            if (gasAvailable <= GasCostOf.CallStipend) return false;
+            if (gasAvailable <= GasCostOf.CallStipend) return EvmExceptionType.OutOfGas;
         }
 
-        stack.PopUInt256(out UInt256 result);
+        if (!stack.PopUInt256(out UInt256 result)) return EvmExceptionType.StackUnderflow;
         Span<byte> bytes = stack.PopWord256();
         bool newIsZero = bytes.IsZero();
         if (!newIsZero)
@@ -2587,7 +2624,7 @@ private bool InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingSt
                 vmState,
                 in storageCell,
                 StorageAccessType.SSTORE,
-                spec)) return false;
+                spec)) return EvmExceptionType.OutOfGas;
 
         Span<byte> currentValue = _state.Get(in storageCell);
         // Console.WriteLine($"current: {currentValue.ToHexString()} newValue {newValue.ToHexString()}");
@@ -2608,14 +2645,14 @@ private bool InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingSt
             }
             else if (currentIsZero)
             {
-                if (!UpdateGas(GasCostOf.SSet - GasCostOf.SReset, ref gasAvailable)) return false;
+                if (!UpdateGas(GasCostOf.SSet - GasCostOf.SReset, ref gasAvailable)) return EvmExceptionType.OutOfGas;
             }
         }
         else // net metered
         {
             if (newSameAsCurrent)
             {
-                if (!UpdateGas(spec.GetNetMeteredSStoreCost(), ref gasAvailable)) return false;
+                if (!UpdateGas(spec.GetNetMeteredSStoreCost(), ref gasAvailable)) return EvmExceptionType.OutOfGas;
             }
             else // net metered, C != N
             {
@@ -2627,11 +2664,11 @@ private bool InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingSt
                 {
                     if (currentIsZero)
                     {
-                        if (!UpdateGas(GasCostOf.SSet, ref gasAvailable)) return false;
+                        if (!UpdateGas(GasCostOf.SSet, ref gasAvailable)) return EvmExceptionType.OutOfGas;
                     }
                     else // net metered, current == original != new, !currentIsZero
                     {
-                        if (!UpdateGas(spec.GetSStoreResetCost(), ref gasAvailable)) return false;
+                        if (!UpdateGas(spec.GetSStoreResetCost(), ref gasAvailable)) return EvmExceptionType.OutOfGas;
 
                         if (newIsZero)
                         {
@@ -2643,7 +2680,7 @@ private bool InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingSt
                 else // net metered, new != current != original
                 {
                     long netMeteredStoreCost = spec.GetNetMeteredSStoreCost();
-                    if (!UpdateGas(netMeteredStoreCost, ref gasAvailable)) return false;
+                    if (!UpdateGas(netMeteredStoreCost, ref gasAvailable)) return EvmExceptionType.OutOfGas;
 
                     if (!originalIsZero) // net metered, new != current != original != 0
                     {
@@ -2698,7 +2735,7 @@ private bool InstructionSStore<TTracingInstructions, TTracingRefunds, TTracingSt
             _txTracer.SetOperationStorage(storageCell.Address, result, bytes, currentValue);
         }
 
-        return true;
+        return EvmExceptionType.None;
     }
 
     private CallResult GetFailureReturn<TTracingInstructions>(long gasAvailable, EvmExceptionType exceptionType)
@@ -2714,6 +2751,7 @@ private CallResult GetFailureReturn<TTracingInstructions>(long gasAvailable, Evm
             EvmExceptionType.InvalidSubroutineEntry => CallResult.InvalidSubroutineEntry,
             EvmExceptionType.InvalidSubroutineReturn => CallResult.InvalidSubroutineReturn,
             EvmExceptionType.StackOverflow => CallResult.StackOverflowException,
+            EvmExceptionType.StackUnderflow => CallResult.StackUnderflowException,
             EvmExceptionType.InvalidJumpDestination => CallResult.InvalidJumpDestination,
             EvmExceptionType.AccessViolation => CallResult.AccessViolationException,
             _ => throw new ArgumentOutOfRangeException(nameof(exceptionType), exceptionType, "")