Add blobhash opcode

Author: r0qs

libevmasm/Instruction.cpp

@@ -81,6 +81,7 @@ std::map<std::string, Instruction> const solidity::evmasm::c_instructions =
 	{ "CHAINID", Instruction::CHAINID },
 	{ "SELFBALANCE", Instruction::SELFBALANCE },
 	{ "BASEFEE", Instruction::BASEFEE },
+	{ "BLOBHASH", Instruction::BLOBHASH },
 	{ "POP", Instruction::POP },
 	{ "MLOAD", Instruction::MLOAD },
 	{ "MSTORE", Instruction::MSTORE },
@@ -230,6 +231,7 @@ static std::map<Instruction, InstructionInfo> const c_instructionInfo =
 	{ Instruction::CHAINID,		{ "CHAINID",		0, 0, 1, false, Tier::Base } },
 	{ Instruction::SELFBALANCE,	{ "SELFBALANCE",	0, 0, 1, false, Tier::Low } },
 	{ Instruction::BASEFEE,     { "BASEFEE",        0, 0, 1, false, Tier::Base } },
+	{ Instruction::BLOBHASH,    { "BLOBHASH",       0, 1, 1, false, Tier::VeryLow } },
 	{ Instruction::POP,			{ "POP",			0, 1, 0, false, Tier::Base } },
 	{ Instruction::MLOAD,		{ "MLOAD",			0, 1, 1, true, Tier::VeryLow } },
 	{ Instruction::MSTORE,		{ "MSTORE",			0, 2, 0, true, Tier::VeryLow } },

libevmasm/Instruction.h

@@ -89,6 +89,7 @@ enum class Instruction: uint8_t
 	CHAINID,			///< get the config's chainid param
 	SELFBALANCE,		///< get balance of the current account
 	BASEFEE,            ///< get the block's basefee
+	BLOBHASH,           ///< get the blob versioned hash
 
 	POP = 0x50,			///< remove item from stack
 	MLOAD,				///< load word from memory

libevmasm/SemanticInformation.cpp

@@ -473,6 +473,7 @@ bool SemanticInformation::invalidInPureFunctions(Instruction _instruction)
 	case Instruction::CALLVALUE:
 	case Instruction::CHAINID:
 	case Instruction::BASEFEE:
+	case Instruction::BLOBHASH:
 	case Instruction::GAS:
 	case Instruction::GASPRICE:
 	case Instruction::EXTCODESIZE:

libevmasm/SimplificationRule.h

@@ -127,6 +127,7 @@ struct EVMBuiltins
 	static auto constexpr CHAINID = PatternGenerator<Instruction::CHAINID>{};
 	static auto constexpr SELFBALANCE = PatternGenerator<Instruction::SELFBALANCE>{};
 	static auto constexpr BASEFEE = PatternGenerator<Instruction::BASEFEE>{};
+	static auto constexpr BLOBHASH = PatternGenerator<Instruction::BLOBHASH>{};
 	static auto constexpr POP = PatternGenerator<Instruction::POP>{};
 	static auto constexpr MLOAD = PatternGenerator<Instruction::MLOAD>{};
 	static auto constexpr MSTORE = PatternGenerator<Instruction::MSTORE>{};

liblangutil/EVMVersion.cpp

@@ -49,6 +49,8 @@ bool EVMVersion::hasOpcode(Instruction _opcode) const
 		return hasSelfBalance();
 	case Instruction::BASEFEE:
 		return hasBaseFee();
+	case Instruction::BLOBHASH:
+		return hasBlobhash();
 	default:
 		return true;
 	}

liblangutil/EVMVersion.h

@@ -103,6 +103,7 @@ class EVMVersion:
 	bool hasBaseFee() const { return *this >= london(); }
 	bool hasPrevRandao() const { return *this >= paris(); }
 	bool hasPush0() const { return *this >= shanghai(); }
+	bool hasBlobhash() const { return *this >= cancun(); }
 
 	bool hasOpcode(evmasm::Instruction _opcode) const;
 

test/EVMHost.cpp

@@ -37,6 +37,12 @@ using namespace solidity::util;
 using namespace solidity::test;
 using namespace evmc::literals;
 
+const std::array<evmc::bytes32, 2> EVMHost::m_blob_hashes =
+{
+	0x0100000000000000000000000000000000000000000000000000000000000001_bytes32,
+	0x0100000000000000000000000000000000000000000000000000000000000002_bytes32
+};
+
 evmc::VM& EVMHost::getVM(string const& _path)
 {
 	static evmc::VM NullVM{nullptr};
@@ -137,6 +143,9 @@ EVMHost::EVMHost(langutil::EVMVersion _evmVersion, evmc::VM& _vm):
 	// The minimum value of basefee
 	tx_context.block_base_fee = evmc::bytes32{7};
 
+	tx_context.blob_hashes = m_blob_hashes.data();
+	tx_context.blob_hashes_count = m_blob_hashes.size();
+
 	// Reserve space for recording calls.
 	if (!recorded_calls.capacity())
 		recorded_calls.reserve(max_recorded_calls);

test/EVMHost.h

@@ -127,6 +127,8 @@ class EVMHost: public evmc::MockedHost
 	static evmc::Result resultWithGas(int64_t gas_limit, int64_t gas_required, bytes const& _data) noexcept;
 	static evmc::Result resultWithFailure() noexcept;
 
+	static const std::array<evmc::bytes32, 2> m_blob_hashes;
+
 	evmc::VM& m_vm;
 	/// EVM version requested by the testing tool
 	langutil::EVMVersion m_evmVersion;

test/libsolidity/semanticTests/builtinFunctions/blobhash.sol

@@ -0,0 +1,11 @@
+contract C {
+    function f() public view returns (bytes32 ret) {
+        assembly {
+            ret := blobhash(0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() -> 0x0100000000000000000000000000000000000000000000000000000000000001

test/libsolidity/semanticTests/builtinFunctions/blobhash_empty.sol

@@ -0,0 +1,11 @@
+contract C {
+    function f() public view returns (bytes32 ret) {
+        assembly {
+            ret := blobhash(3)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() -> 0x00