Merge audit branches: zellic-audit => veridise-audit

.github/workflows/test.yml

@@ -5,13 +5,11 @@ on:
   push:
     branches:
       - seismic
-      - veridise-audit
+      - merge-audits-final
   pull_request:
     branches:
-      # NOTE: seismic temporarily removed to avoid duplicate builds from veridise-audit→seismic PR.
-      # Re-enable after veridise-audit merges to seismic.
-      # - seismic
-      - veridise-audit
+      - seismic
+      - merge-audits-final
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}

liblangutil/EVMVersion.cpp

@@ -63,6 +63,7 @@ bool EVMVersion::hasOpcode(Instruction _opcode, std::optional<uint8_t> _eofVersi
 		return supportsTransientStorage();
 	case Instruction::CLOAD:
 	case Instruction::CSTORE:
+	case Instruction::TIMESTAMPMS:
 		return supportShieldedStorage() && !_eofVersion.has_value();
 	// Instructions below are deprecated in EOF
 	case Instruction::CALL:

liblangutil/EVMVersion.h

@@ -148,6 +148,7 @@ class EVMVersion
 	bool hasMcopy() const { return *this >= cancun(); }
 	bool supportsTransientStorage() const { return *this >= cancun(); }
 	bool supportShieldedStorage() const { return *this >= mercury(); }
+	bool hasTimestampMs() const { return *this >= mercury(); }
 	bool supportsEOF() const { return *this >= firstWithEOF(); }
 
 	bool hasOpcode(evmasm::Instruction _opcode, std::optional<uint8_t> _eofVersion) const;

libsolidity/analysis/TypeChecker.cpp

@@ -3718,6 +3718,18 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 					_memberAccess.location(),
 					"Since the VM version paris, \"difficulty\" was replaced by \"prevrandao\", which now returns a random number based on the beacon chain."
 				);
+			else if (memberName == "timestamp_ms" && !m_evmVersion.hasTimestampMs())
+				m_errorReporter.typeError(
+					4521_error,
+					_memberAccess.location(),
+					"\"timestamp_ms\" is not supported by the VM version."
+				);
+			else if (memberName == "timestamp_seconds" && !m_evmVersion.hasTimestampMs())
+				m_errorReporter.typeError(
+					8743_error,
+					_memberAccess.location(),
+					"\"timestamp_seconds\" is not supported by the VM version."
+				);
 		}
 	}
 

libsolidity/codegen/CompilerUtils.cpp

@@ -933,7 +933,7 @@ void CompilerUtils::convertType(
 		}
 		else if (targetTypeCategory == Type::Category::Enum)
 		{
-			solAssert((stackTypeCategory != Type::Category::Address || stackTypeCategory != Type::Category::ShieldedAddress), "Invalid conversion to EnumType requested.");
+			solAssert((stackTypeCategory != Type::Category::Address && stackTypeCategory != Type::Category::ShieldedAddress), "Invalid conversion to EnumType requested.");
 			solAssert(_typeOnStack.mobileType());
 			// just clean
 			convertType(_typeOnStack, *_typeOnStack.mobileType(), true);

libsolidity/formal/Predicate.cpp

@@ -252,6 +252,8 @@ std::string Predicate::formatSummaryCall(
 					// TODO remove this for 0.9.0
 					if (magicKind == MagicType::Kind::Block && memberName == "difficulty")
 						memberName = "prevrandao";
+					if (magicKind == MagicType::Kind::Block && memberName == "timestamp_seconds")
+						memberName = "timestamp";
 
 					if (magicKind == MagicType::Kind::Block || magicKind == MagicType::Kind::Message || magicKind == MagicType::Kind::Transaction)
 						txVars.insert(magicType->toString(true) + "." + memberName);

libsolidity/formal/SMTEncoder.cpp

@@ -1420,13 +1420,20 @@ bool SMTEncoder::visit(MemberAccess const& _memberAccess)
 			// TODO remove this for 0.9.0
 			if (name == "block" && memberName == "difficulty")
 				memberName = "prevrandao";
+			if (name == "block" && memberName == "timestamp_seconds")
+				memberName = "timestamp";
 
 			defineExpr(_memberAccess, state().txMember(name + "." + memberName));
 		}
 		else if (auto magicType = dynamic_cast<MagicType const*>(exprType))
 		{
 			if (magicType->kind() == MagicType::Kind::Block)
-				defineExpr(_memberAccess, state().txMember("block." + _memberAccess.memberName()));
+			{
+				auto memberName = _memberAccess.memberName();
+				if (memberName == "timestamp_seconds")
+					memberName = "timestamp";
+				defineExpr(_memberAccess, state().txMember("block." + memberName));
+			}
 			else if (magicType->kind() == MagicType::Kind::Message)
 				defineExpr(_memberAccess, state().txMember("msg." + _memberAccess.memberName()));
 			else if (magicType->kind() == MagicType::Kind::Transaction)

libsolidity/formal/SymbolicState.cpp

@@ -235,7 +235,6 @@ smtutil::Expression SymbolicState::txTypeConstraints() const
 		smt::symbolicUnknownConstraints(m_tx.member("block.number"), TypeProvider::uint256()) &&
 		smt::symbolicUnknownConstraints(m_tx.member("block.timestamp"), TypeProvider::uint256()) &&
 		smt::symbolicUnknownConstraints(m_tx.member("block.timestamp_ms"), TypeProvider::uint256()) &&
-		smt::symbolicUnknownConstraints(m_tx.member("block.timestamp_seconds"), TypeProvider::uint256()) &&
 		smt::symbolicUnknownConstraints(m_tx.member("msg.sender"), TypeProvider::address()) &&
 		smt::symbolicUnknownConstraints(m_tx.member("msg.value"), TypeProvider::uint256()) &&
 		smt::symbolicUnknownConstraints(m_tx.member("tx.origin"), TypeProvider::address()) &&

libsolidity/formal/SymbolicTypes.cpp

@@ -686,7 +686,6 @@ std::map<std::string, frontend::Type const*> transactionMemberTypes()
 		{"block.number", TypeProvider::uint256()},
 		{"block.timestamp", TypeProvider::uint256()},
 		{"block.timestamp_ms", TypeProvider::uint256()},
-		{"block.timestamp_seconds", TypeProvider::uint256()},
 		{"blobhash", TypeProvider::array(DataLocation::Memory, TypeProvider::uint256())},
 		{"blockhash", TypeProvider::array(DataLocation::Memory, TypeProvider::uint256())},
 		{"msg.data", TypeProvider::bytesCalldata()},

libyul/AsmAnalysis.cpp

@@ -852,7 +852,7 @@ bool AsmAnalyzer::validateInstructions(evmasm::Instruction _instr, SourceLocatio
 		errorForVM(7755_error, "only available for Cancun-compatible");
 	else if ((_instr == evmasm::Instruction::TSTORE || _instr == evmasm::Instruction::TLOAD) && !m_evmVersion.supportsTransientStorage())
 		errorForVM(6243_error, "only available for Cancun-compatible");
-	else if ((_instr == evmasm::Instruction::CLOAD || _instr == evmasm::Instruction::CSTORE) && !m_evmVersion.supportShieldedStorage())
+	else if ((_instr == evmasm::Instruction::CLOAD || _instr == evmasm::Instruction::CSTORE || _instr == evmasm::Instruction::TIMESTAMPMS) && !m_evmVersion.supportShieldedStorage())
 		errorForVM(6245_error, "only available for Mercury-compatible");
 	else if (_instr == evmasm::Instruction::PC)
 		m_errorReporter.error(

libyul/backends/evm/EVMDialect.cpp

@@ -137,7 +137,7 @@ std::set<std::string, std::less<>> createReservedIdentifiers(langutil::EVMVersio
 	{
 		return
 			_evmVersion < langutil::EVMVersion::mercury() &&
-			(_instr == evmasm::Instruction::CSTORE || _instr == evmasm::Instruction::CLOAD);
+			(_instr == evmasm::Instruction::CSTORE || _instr == evmasm::Instruction::CLOAD || _instr == evmasm::Instruction::TIMESTAMPMS);
 	};
 
 	auto eofIdentifiersException = [&](evmasm::Instruction _instr) -> bool

test/cmdlineTests/shielded_sbytes16_via_ir/args

@@ -0,0 +1 @@
+--asm --via-ir

test/cmdlineTests/shielded_sbytes16_via_ir/input.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    sbytes16 data;
+    function test() external {
+        data = sbytes16(0);
+    }
+}

test/cmdlineTests/shielded_sbytes16_via_ir/output

@@ -0,0 +1,231 @@
+Warning: This is a pre-release compiler version, please do not use it in production.
+
+
+======= shielded_sbytes16_via_ir/input.sol:C =======
+EVM assembly:
+    /* "shielded_sbytes16_via_ir/input.sol":60:158  contract C {... */
+  mstore(0x40, 0x80)
+  jumpi(tag_3, callvalue)
+  tag_5
+  tag_1
+  jump	// in
+tag_5:
+  dataSize(sub_0)
+  dataOffset(sub_0)
+  dup3
+  codecopy
+  dataSize(sub_0)
+  swap1
+  return
+tag_3:
+  tag_2
+  jump	// in
+tag_1:
+  mload(0x40)
+  swap1
+  jump	// out
+tag_2:
+  0x00
+  dup1
+  revert
+stop
+
+sub_0: assembly {
+        /* "shielded_sbytes16_via_ir/input.sol":60:158  contract C {... */
+      mstore(0x40, 0x80)
+      jumpi(tag_20, iszero(lt(calldatasize, 0x04)))
+    tag_21:
+      tag_8
+      jump	// in
+    tag_20:
+      tag_22
+      calldataload(0x00)
+      tag_1
+      jump	// in
+    tag_22:
+      0xf8a8fd6d
+      sub
+      tag_21
+      jumpi
+      tag_7
+      jump	// in
+    tag_1:
+      0xe0
+      shr
+      swap1
+      jump	// out
+    tag_2:
+      mload(0x40)
+      swap1
+      jump	// out
+    tag_3:
+      0x00
+      dup1
+      revert
+    tag_4:
+      0x00
+      dup1
+      revert
+    tag_5:
+      0x00
+      swap2
+      sub
+      slt
+      tag_25
+      jumpi
+      jump	// out
+    tag_25:
+      tag_4
+      jump	// in
+    tag_6:
+      0x00
+      add
+      swap1
+      jump	// out
+    tag_7:
+      jumpi(tag_27, callvalue)
+      tag_29
+      calldatasize
+      0x04
+      tag_5
+      jump	// in
+    tag_29:
+      tag_30
+      tag_19
+      jump	// in
+    tag_30:
+      tag_31
+      tag_2
+      jump	// in
+    tag_31:
+      dup1
+      tag_32
+      dup2
+      tag_6
+      jump	// in
+    tag_32:
+      sub
+      swap1
+      return
+    tag_27:
+      tag_3
+      jump	// in
+    tag_8:
+      0x00
+      dup1
+      revert
+    tag_9:
+      swap1
+      jump	// out
+    tag_10:
+      not(0xffffffffffffffffffffffffffffffff)
+      and
+      swap1
+      jump	// out
+    tag_11:
+      0x80
+      shl
+      swap1
+      jump	// out
+    tag_12:
+      tag_33
+      tag_34
+      tag_35
+      swap3
+      tag_9
+      jump	// in
+    tag_34:
+      tag_11
+      jump	// in
+    tag_33:
+      tag_10
+      jump	// in
+    tag_35:
+      swap1
+      jump	// out
+    tag_13:
+      0x00
+      shl
+      swap1
+      jump	// out
+    tag_14:
+      swap1
+      tag_36
+      not(0x00)
+      swap2
+      tag_13
+      jump	// in
+    tag_36:
+      swap2
+      dup2
+      not
+      and
+      swap2
+      and
+      or
+      swap1
+      jump	// out
+    tag_15:
+      tag_37
+      swap1
+      tag_10
+      jump	// in
+    tag_37:
+      swap1
+      jump	// out
+    tag_16:
+      0x00
+      shr
+      swap1
+      jump	// out
+    tag_17:
+      tag_38
+      swap1
+      tag_16
+      jump	// in
+    tag_38:
+      swap1
+      jump	// out
+    tag_18:
+      swap1
+      tag_39
+      tag_40
+      tag_41
+      swap3
+      tag_15
+      jump	// in
+    tag_40:
+      tag_17
+      jump	// in
+    tag_39:
+      dup3
+      cload
+      tag_14
+      jump	// in
+    tag_41:
+      swap1
+      cstore
+      jump	// out
+        /* "shielded_sbytes16_via_ir/input.sol":96:156  function test() external {... */
+    tag_19:
+        /* "shielded_sbytes16_via_ir/input.sol":131:149  data = sbytes16(0) */
+      tag_42
+        /* "shielded_sbytes16_via_ir/input.sol":138:149  sbytes16(0) */
+      tag_43
+        /* "shielded_sbytes16_via_ir/input.sol":147:148  0 */
+      0x00
+        /* "shielded_sbytes16_via_ir/input.sol":138:149  sbytes16(0) */
+      tag_12
+      jump	// in
+    tag_43:
+        /* "shielded_sbytes16_via_ir/input.sol":131:149  data = sbytes16(0) */
+      0x00
+      tag_18
+      jump	// in
+    tag_42:
+        /* "shielded_sbytes16_via_ir/input.sol":96:156  function test() external {... */
+      jump	// out
+
+    auxdata: 0xa264697066735822122037b55db07a67fb1a37064c30080d17923eabae62f0cdd6d344db02a833c23ccb64736f6c63782c302e382e33312d646576656c6f702e323032362e312e32312b636f6d6d69742e38346365363530622e6d6f64005d
+}
+

test/cmdlineTests/shielded_sbytes1_via_ir/args

@@ -0,0 +1 @@
+--asm --via-ir

test/cmdlineTests/shielded_sbytes1_via_ir/input.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    sbytes1 data;
+    function test() external {
+        data = sbytes1(0);
+    }
+}