feat: support strings and accept a constant for __VERBATIM (#151)

Author: cakevm

CHANGELOG.md

@@ -5,6 +5,13 @@
 ## Unreleased
 - Fix constants defined with builtin functions not working in code tables (fixes #149).
   - Example: `#define constant C = __RIGHTPAD(0x)` can now be used in tables with `[C]`.
+- Add support for string literal constants with `__BYTES` builtin function.
+  - String constants can be defined: `#define constant GREETING = "hello"`.
+  - String constants must be used with `__BYTES`: `__BYTES([GREETING])` converts to UTF-8 bytes.
+  - Example: `#define constant MSG = "hello"` then `__BYTES([MSG])` produces `0x68656c6c6f`.
+- Add support for constant references in `__VERBATIM` builtin function.
+  - `__VERBATIM` can now accept constant references: `__VERBATIM([MY_CONSTANT])`.
+  - Example: `#define constant SIG = __FUNC_SIG("transfer(address,uint256)")` then `__VERBATIM([SIG])`.
 
 ## [1.5.5] - 2025-11-08
 - Fix `--relax-jumps` not updating label positions always correct during iterative optimization.

book/huff-language/builtin-functions.md

@@ -38,16 +38,67 @@ Pushes the code size of the macro or function passed to the stack.
 ### `__tablestart(<table>)` and `__tablesize(<table>)`
 These functions related to Jump Tables are described in the next section.
 
-### `__VERBATIM(<hex>)`
+### `__VERBATIM(<hex>|<constant>)`
 This function is used to insert raw hex data into the compiled bytecode. It is useful for inserting raw opcodes or data into the compiled bytecode.
 
-### `__BYTES(<string>)`
-This function allows to insert a string as UTF-8 encoded bytes into the compiled bytecode. The resulting bytecode is limited to 32 bytes.
+You can pass either:
+- A hex literal directly: `__VERBATIM(0x1234)`
+- A constant reference: `__VERBATIM([MY_CONSTANT])`
 
-#### Example
+#### Examples
+
+**Direct hex literal:**
+```javascript
+#define macro MAIN() = takes (0) returns (0) {
+    __VERBATIM(0x1234)  // Inserts raw bytes 0x1234
+}
+```
+
+**Constant reference:**
 ```javascript
+#define constant SIG = __FUNC_SIG("transfer(address,uint256)")
+
+#define macro MAIN() = takes (0) returns (0) {
+    __VERBATIM([SIG])  // Inserts the function selector bytes
+}
+```
+
+### `__BYTES(<string>|<string constant>)`
+This function converts a string to UTF-8 encoded bytes and inserts them into the compiled bytecode. The resulting bytecode is limited to 32 bytes.
+
+You can pass either:
+- A string literal directly: `__BYTES("hello")`
+- A string constant reference: `__BYTES([GREETING])` where `GREETING` is a string constant
+
+**Note:** `__BYTES` only accepts string values. Hex constants are not allowed and will result in a compilation error.
+
+#### Examples
+
+**Direct string literal:**
+```javascript
+#define macro MAIN() = takes (0) returns (0) {
+    __BYTES("hello")  // Compiles to: PUSH5 0x68656c6c6f
+}
+```
+
+**String constant reference:**
+```javascript
+#define constant GREETING = "hello"
+#define constant ERROR_MSG = "Unauthorized"
+
+#define macro MAIN() = takes (0) returns (0) {
+    __BYTES([GREETING])    // Compiles to: PUSH5 0x68656c6c6f
+    __BYTES([ERROR_MSG])   // Compiles to: PUSH12 0x556e617574686f72697a6564
+}
+```
+
+**Chained `__BYTES` constants:**
+```javascript
+#define constant MSG = "test"
+#define constant MSG_BYTES = __BYTES([MSG])
+
 #define macro MAIN() = takes (0) returns (0) {
-    __BYTES("hello") // Will push UTF-8 encoded string (PUSH5 0x68656c6c6f)
+    [MSG_BYTES]  // Uses the pre-computed bytes
 }
 ```
 

book/huff-language/code-table.md

@@ -40,3 +40,16 @@ somewhere within the contract.
 }
 ```
 
+### Usage of builtin function constants
+```javascript
+#define constant SIG = __FUNC_SIG("transfer(address,uint256)")
+#define constant PADDED = __RIGHTPAD(0x42)
+
+#define table CODE_TABLE {
+    [SIG]       // Function selector from constant
+    [PADDED]    // Padded value from constant
+}
+```
+
+This is particularly useful when you want to reuse computed builtin values in multiple places, including both code and data tables.
+

book/huff-language/constants.md

@@ -2,7 +2,7 @@
 
 Constants in Huff contracts are not included in the contract's storage; Instead,
 they are able to be called within the contract at compile time. Constants
-can be bytes (32 max), `FREE_STORAGE_POINTER`, a built-in function, or an arithmetic expression.
+can be bytes (32 max), string literals, `FREE_STORAGE_POINTER`, a built-in function, or an arithmetic expression.
 A `FREE_STORAGE_POINTER` constant will always represent an unused storage slot in the contract.
 
 In order to push a constant to the stack, use bracket notation: `[CONSTANT]`
@@ -13,6 +13,7 @@ In order to push a constant to the stack, use bracket notation: `[CONSTANT]`
 ```javascript
 #define constant NUM = 0x420
 #define constant HELLO_WORLD = 0x48656c6c6f2c20576f726c6421
+#define constant GREETING = "hello"
 #define constant FREE_STORAGE = FREE_STORAGE_POINTER()
 #define constant TEST = __FUNC_SIG("test(uint256)")
 ```
@@ -131,4 +132,69 @@ Expressions are evaluated during compilation. The compiler replaces the expressi
 #define macro EXAMPLE() = takes(0) returns(0) {
     [C]    // Compiles to: PUSH1 0x15
 }
+```
+
+## String Literals
+
+String literal constants can be defined using double quotes. String constants cannot be pushed to the stack directly - they must be converted to bytes using the `__BYTES` builtin function.
+
+### String Constant Declaration
+
+```javascript
+#define constant GREETING = "hello"
+#define constant MESSAGE = "transfer(address,uint256)"
+```
+
+### String Constant Usage
+
+String constants must be used with the `__BYTES` builtin function, which converts the string to UTF-8 encoded bytes:
+
+```javascript
+#define constant GREETING = "hello"
+
+#define macro MAIN() = takes(0) returns(0) {
+    __BYTES([GREETING])  // Compiles to: PUSH5 0x68656c6c6f
+}
+```
+
+**Direct usage is not allowed:**
+```javascript
+// ❌ ERROR: String constants cannot be pushed directly
+#define constant MSG = "hello"
+
+#define macro EXAMPLE() = takes(0) returns(0) {
+    [MSG]  // Compilation error: use __BYTES([MSG]) instead
+}
+```
+
+### Use Cases
+
+**Function Signatures:**
+```javascript
+#define constant TRANSFER_SIG = "transfer(address,uint256)"
+
+#define macro GET_SELECTOR() = takes(0) returns(1) {
+    __BYTES([TRANSFER_SIG])  // Push signature as bytes
+}
+```
+
+**Error Messages (limited to 32 bytes):**
+```javascript
+#define constant ERROR_MSG = "Insufficient balance"
+
+#define macro REVERT_WITH_MSG() = takes(0) returns(0) {
+    __BYTES([ERROR_MSG])
+    0x00 mstore
+    0x20 0x00 revert
+}
+```
+
+**Combining with Other Builtins:**
+```javascript
+#define constant GREETING = "hi"
+
+#define macro EXAMPLE() = takes(0) returns(0) {
+    // String bytes can be padded
+    __RIGHTPAD(__BYTES([GREETING]))  // Right-pad the UTF-8 bytes
+}
 ```

crates/codegen/src/irgen/arg_calls.rs

@@ -284,8 +284,8 @@ pub fn bubble_arg_call<'a>(
                     // Original handling for other argument types
                     tracing::info!(target: "codegen", "GOT \"{:?}\" ARG FROM MACRO INVOCATION", arg);
                     match arg {
-                        MacroArg::Literal(l) => {
-                            tracing::info!(target: "codegen", "GOT LITERAL {} ARG FROM MACRO INVOCATION", bytes32_to_hex_string(l, false));
+                        MacroArg::HexLiteral(l) => {
+                            tracing::info!(target: "codegen", "GOT HEX LITERAL {} ARG FROM MACRO INVOCATION", bytes32_to_hex_string(l, false));
                             let push_bytes = literal_gen(evm_version, l);
                             *offset += push_bytes.len() / 2;
                             bytes.push_with_offset(starting_offset, Bytes::Raw(push_bytes));
@@ -387,6 +387,16 @@ pub fn bubble_arg_call<'a>(
                                         let hex_literal: String = bytes.as_str().to_string();
                                         format!("{:02x}{hex_literal}", 95 + hex_literal.len() / 2)
                                     }
+                                    ConstVal::String(_s) => {
+                                        return Err(CodegenError {
+                                            kind: CodegenErrorKind::StringConstantNotBytes(format!(
+                                                "String constant [{}] cannot be pushed directly. Use __BYTES([{}]) to convert it to bytes.",
+                                                iden, iden
+                                            )),
+                                            span: Box::new(target_macro_invoc.1.span.clone()),
+                                            token: None,
+                                        });
+                                    }
                                     ConstVal::StoragePointer(sp) => {
                                         let hex_literal: String = bytes32_to_hex_string(sp, false);
                                         format!("{:02x}{hex_literal}", 95 + hex_literal.len() / 2)