fix: constant substitution should not fail when referencing builtin functions (#127)

Author: cakevm

CHANGELOG.md

@@ -5,6 +5,9 @@
 ## Unreleased
 - Add compile-time if/else if/else statements.
   - Example: `if ([MODE] == 0x01) { 0xAA } else if ([MODE] == 0x02) { 0xBB } else { 0xCC }`
+- Fix constant substitution failing when referencing builtin functions (fixes #122).
+  - Example: `#define constant C1 = __RIGHTPAD(0x)` and `#define constant C2 = [C1]` now works correctly.
+  - Applies to all builtin functions: `__FUNC_SIG`, `__EVENT_HASH`, `__RIGHTPAD`, `__LEFTPAD`, `__BYTES`.
 
 ## [1.5.1] - 2025-11-04
 - Throw error for circular constant dependencies to prevent infinite loops during constant evaluation.

crates/codegen/src/irgen/builtin_function.rs

@@ -1,6 +1,7 @@
 use crate::Codegen;
 use crate::irgen::constants::{constant_gen, evaluate_constant_value};
 use alloy_primitives::{B256, hex, keccak256};
+use huff_neo_utils::builtin_eval::{PadDirection, eval_builtin_bytes, eval_event_hash, eval_function_signature};
 use huff_neo_utils::bytecode::{BytecodeRes, Bytes, CircularCodeSizeIndices, Jump, Jumps};
 use huff_neo_utils::bytes_util::{bytes32_to_hex_string, format_even_bytes, pad_n_bytes};
 use huff_neo_utils::error::{CodegenError, CodegenErrorKind};
@@ -10,7 +11,6 @@ use huff_neo_utils::prelude::{
     Argument, AstSpan, BuiltinFunctionArg, BuiltinFunctionCall, BuiltinFunctionKind, Contract, MacroDefinition, MacroInvocation, PushValue,
     TableDefinition,
 };
-use std::fmt::Display;
 
 /// Creates a CodegenError for invalid arguments
 fn invalid_arguments_error(msg: impl Into<String>, span: &AstSpan) -> CodegenError {
@@ -139,13 +139,13 @@ pub fn builtin_function_gen<'a>(
             }
         }
         BuiltinFunctionKind::FunctionSignature => {
-            let push_value = function_signature(contract, bf)?;
+            let push_value = eval_function_signature(contract, bf)?;
             let push_bytes = push_value.to_hex_with_opcode(evm_version);
             *offset += push_bytes.len() / 2;
             bytes.push((starting_offset, Bytes(push_bytes)));
         }
         BuiltinFunctionKind::EventHash => {
-            let push_value = event_hash(contract, bf)?;
+            let push_value = eval_event_hash(contract, bf)?;
             let push_bytes = push_value.to_hex_with_opcode(evm_version);
             *offset += push_bytes.len() / 2;
             bytes.push((starting_offset, Bytes(push_bytes)));
@@ -231,7 +231,7 @@ pub fn builtin_function_gen<'a>(
             bytes.push((starting_offset, Bytes(push_bytes)));
         }
         BuiltinFunctionKind::Bytes => {
-            let push_value = builtin_bytes(bf)?;
+            let push_value = eval_builtin_bytes(bf)?;
             let push_bytes = push_value.to_hex_with_opcode(evm_version);
             *offset += push_bytes.len() / 2;
             bytes.push((starting_offset, Bytes(push_bytes)));
@@ -440,86 +440,15 @@ pub fn tablesize(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<(Table
     Ok((ir_table, push_bytes))
 }
 
-/// Generates a PushValue for the __EVENT_HASH builtin function
-///
-/// Returns a PushValue containing the full keccak256 hash (32 bytes) of the event signature.
-/// Looks up event definitions in the contract or computes the hash via keccak256.
-pub fn event_hash(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<PushValue, CodegenError> {
-    validate_arg_count(bf, 1, "__EVENT_HASH")?;
-    let first_arg = extract_single_argument(bf, "__EVENT_HASH")?;
-    let hash = if let Some(event) = contract.events.iter().find(|e| first_arg.name.as_ref().unwrap().eq(&e.name)) {
-        event.hash
-    } else if let Some(s) = &first_arg.name {
-        keccak256(s).0
-    } else {
-        tracing::error!(
-            target: "codegen",
-            "MISSING EVENT INTERFACE PASSED TO __EVENT_HASH: \"{}\"",
-            first_arg.name.as_ref().unwrap()
-        );
-        return Err(CodegenError {
-            kind: CodegenErrorKind::MissingEventInterface(first_arg.name.as_ref().unwrap().to_string()),
-            span: bf.span.clone_box(),
-            token: None,
-        });
-    };
-    Ok(PushValue::from(hash))
-}
-
-/// Generates a PushValue for the __FUNC_SIG builtin function
-///
-/// Returns a PushValue containing the 4-byte function selector (first 4 bytes of keccak256 hash).
-/// Looks up function/error definitions in the contract or computes the selector via keccak256.
-pub fn function_signature(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<PushValue, CodegenError> {
-    validate_arg_count(bf, 1, "__FUNC_SIG")?;
-    let first_arg = extract_single_argument(bf, "__FUNC_SIG")?;
-    let selector = if let Some(func) = contract.functions.iter().find(|f| first_arg.name.as_ref().unwrap().eq(&f.name)) {
-        func.signature
-    } else if let Some(error) = contract.errors.iter().find(|e| first_arg.name.as_ref().unwrap().eq(&e.name)) {
-        error.selector
-    } else if let Some(s) = &first_arg.name {
-        keccak256(s)[..4].try_into().unwrap()
-    } else {
-        tracing::error!(
-            target: "codegen",
-            "MISSING FUNCTION INTERFACE PASSED TO __SIG: \"{}\"",
-            first_arg.name.as_ref().unwrap()
-        );
-        return Err(CodegenError {
-            kind: CodegenErrorKind::MissingFunctionInterface(first_arg.name.as_ref().unwrap().to_string()),
-            span: bf.span.clone_box(),
-            token: None,
-        });
-    };
-
-    // Left-pad the 4-byte selector to 32 bytes for B256
-    let mut bytes = [0u8; 32];
-    bytes[28..32].copy_from_slice(&selector);
-    Ok(PushValue::from(bytes))
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum PadDirection {
-    Left,
-    Right,
-}
-impl Display for PadDirection {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            PadDirection::Left => write!(f, "__LEFTPAD"),
-            PadDirection::Right => write!(f, "__RIGHTPAD"),
-        }
-    }
-}
-
 /// Generates a PushValue for left or right padding a byte string to 32 bytes
 pub fn builtin_pad(contract: &Contract, bf: &BuiltinFunctionCall, direction: PadDirection) -> Result<PushValue, CodegenError> {
     validate_arg_count(bf, 1, &direction.to_string())?;
     let first_arg = match &bf.args[0] {
         BuiltinFunctionArg::Argument(arg) => arg.name.clone().unwrap_or_default(),
         BuiltinFunctionArg::BuiltinFunctionCall(inner_call) => match inner_call.kind {
-            BuiltinFunctionKind::FunctionSignature => function_signature(contract, inner_call)?.to_hex_trimmed(),
-            BuiltinFunctionKind::Bytes => builtin_bytes(inner_call)?.to_hex_trimmed(),
+            BuiltinFunctionKind::FunctionSignature => eval_function_signature(contract, inner_call)?.to_hex_trimmed(),
+            BuiltinFunctionKind::Bytes => eval_builtin_bytes(inner_call)?.to_hex_trimmed(),
+            BuiltinFunctionKind::EventHash => eval_event_hash(contract, inner_call)?.to_hex_trimmed(),
             _ => {
                 tracing::error!(target: "codegen", "Invalid function call argument type passed to {direction}");
                 return Err(invalid_arguments_error(format!("Invalid argument type passed to {direction}"), &bf.span));
@@ -554,34 +483,3 @@ pub fn builtin_pad(contract: &Contract, bf: &BuiltinFunctionCall, direction: Pad
 
     Ok(PushValue::new(B256::from(bytes_array)))
 }
-
-/// Validates and converts a string argument to a right-padded 32-byte array
-fn validate_and_pad_string(bf: &BuiltinFunctionCall) -> Result<[u8; 32], CodegenError> {
-    validate_arg_count(bf, 1, "__BYTES")?;
-    let first_arg = match bf.args[0] {
-        BuiltinFunctionArg::Argument(ref arg) => arg.name.clone().unwrap_or_default(),
-        _ => {
-            tracing::error!(target: "codegen", "Invalid argument type passed to __BYTES");
-            return Err(invalid_arguments_error("Invalid argument type passed to __BYTES", &bf.span));
-        }
-    };
-
-    if first_arg.is_empty() {
-        return Err(invalid_arguments_error("Empty string passed to __BYTES", &bf.span));
-    }
-
-    let bytes = first_arg.as_bytes();
-    if bytes.len() > 32 {
-        return Err(invalid_arguments_error("Encoded bytes length exceeds 32 bytes", &bf.span));
-    }
-
-    let mut bytes_array = [0u8; 32];
-    bytes_array[32 - bytes.len()..].copy_from_slice(bytes);
-    Ok(bytes_array)
-}
-
-/// Generates a PushValue for the __BYTES builtin function
-pub fn builtin_bytes(bf: &BuiltinFunctionCall) -> Result<PushValue, CodegenError> {
-    let bytes_array = validate_and_pad_string(bf)?;
-    Ok(PushValue::new(B256::from(bytes_array)))
-}

crates/codegen/src/lib.rs

@@ -3,7 +3,7 @@
 #![warn(unused_extern_crates)]
 #![forbid(unsafe_code)]
 
-use crate::irgen::builtin_function::{PadDirection, builtin_bytes, builtin_pad, function_signature};
+use crate::irgen::builtin_function::builtin_pad;
 use alloy_primitives::{U256, hex};
 use huff_neo_utils::ast::huff::*;
 use huff_neo_utils::ast::span::AstSpan;
@@ -429,9 +429,11 @@ impl Codegen {
     /// Generates bytecode for a builtin function call used for constants, code tables, etc.
     /// Returns a PushValue that can be converted to bytecode with or without opcode
     pub fn gen_builtin_bytecode(contract: &Contract, bf: &BuiltinFunctionCall, span: AstSpan) -> Result<PushValue, CodegenError> {
+        use huff_neo_utils::builtin_eval::{PadDirection, eval_builtin_bytes, eval_event_hash, eval_function_signature};
         match bf.kind {
-            BuiltinFunctionKind::FunctionSignature => function_signature(contract, bf),
-            BuiltinFunctionKind::Bytes => builtin_bytes(bf),
+            BuiltinFunctionKind::FunctionSignature => eval_function_signature(contract, bf),
+            BuiltinFunctionKind::Bytes => eval_builtin_bytes(bf),
+            BuiltinFunctionKind::EventHash => eval_event_hash(contract, bf),
             BuiltinFunctionKind::LeftPad => builtin_pad(contract, bf, PadDirection::Left),
             BuiltinFunctionKind::RightPad => builtin_pad(contract, bf, PadDirection::Right),
             _ => Err(CodegenError {

crates/core/tests/builtin_in_constant_reference.rs

@@ -0,0 +1,196 @@
+mod common;
+
+#[test]
+fn test_rightpad_in_constant_reference() {
+    let source = r#"
+        #define constant C1 = __RIGHTPAD(0x)
+        #define constant C2 = [C1]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [C2]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // __RIGHTPAD(0x) produces 32 zero bytes, optimized to PUSH1 0x00
+    assert_eq!(bytecode, "5f"); // PUSH0 (0x5f) in Shanghai+ or PUSH1 0x00 in earlier versions
+}
+
+#[test]
+fn test_func_sig_in_constant_reference() {
+    let source = r#"
+        #define constant SIG = __FUNC_SIG("transfer(address,uint256)")
+        #define constant SELECTOR = [SIG]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [SELECTOR]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // transfer(address,uint256) signature = 0xa9059cbb
+    // PUSH4 = 0x63
+    assert_eq!(bytecode, "63a9059cbb");
+}
+
+#[test]
+fn test_event_hash_in_constant_reference() {
+    let source = r#"
+        #define constant HASH = __EVENT_HASH("Transfer(address,address,uint256)")
+        #define constant EVENT_TOPIC = [HASH]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [EVENT_TOPIC]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // Transfer(address,address,uint256) event hash
+    // keccak256("Transfer(address,address,uint256)") = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
+    // PUSH32 = 0x7f
+    assert_eq!(bytecode, "7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef");
+}
+
+#[test]
+fn test_bytes_in_constant_reference() {
+    let source = r#"
+        #define constant B = __BYTES("hello")
+        #define constant BYTES_VAL = [B]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [BYTES_VAL]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // "hello" as bytes, right-padded to 32 bytes: 0x68656c6c6f (followed by zeros)
+    // Since it's only 5 bytes, it will be optimized to PUSH5
+    // PUSH5 = 0x64
+    assert_eq!(bytecode, "6468656c6c6f");
+}
+
+#[test]
+fn test_nested_constant_references_with_builtin() {
+    let source = r#"
+        #define constant C1 = __FUNC_SIG("test()")
+        #define constant C2 = [C1]
+        #define constant C3 = [C2]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [C3]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // test() signature = keccak256("test()")[0..4] = 0xf8a8fd6d
+    // PUSH4 = 0x63
+    assert_eq!(bytecode, "63f8a8fd6d");
+}
+
+#[test]
+fn test_builtin_in_arithmetic_expression() {
+    let source = r#"
+        #define constant SIG = __FUNC_SIG("test()")
+        #define constant OFFSET = [SIG] + 1
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [OFFSET]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // test() signature = 0xf8a8fd6d = 4171875693
+    // 4171875693 + 1 = 4171875694 = 0xf8a8fd6e
+    // PUSH4 = 0x63
+    assert_eq!(bytecode, "63f8a8fd6e");
+}
+
+#[test]
+fn test_leftpad_in_constant_reference() {
+    let source = r#"
+        #define constant PADDED = __LEFTPAD(0x42)
+        #define constant VAL = [PADDED]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [VAL]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // __LEFTPAD(0x42) produces 0x0000...0042 (left-padded to 32 bytes)
+    // This is just 0x42, which gets optimized to PUSH1
+    // PUSH1 = 0x60
+    assert_eq!(bytecode, "6042");
+}
+
+#[test]
+fn test_rightpad_vs_leftpad() {
+    let source_right = r#"
+        #define constant PADDED = __RIGHTPAD(0x42)
+        #define constant VAL = [PADDED]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [VAL]
+        }
+    "#;
+
+    let bytecode_right = common::compile_to_bytecode(source_right).unwrap();
+    // __RIGHTPAD(0x42) produces 0x4200...0000 (right-padded to 32 bytes)
+    // This is 0x42 followed by 31 zero bytes
+    // PUSH32 = 0x7f (full 32 bytes)
+    assert_eq!(bytecode_right, "7f4200000000000000000000000000000000000000000000000000000000000000");
+
+    let source_left = r#"
+        #define constant PADDED = __LEFTPAD(0x42)
+        #define constant VAL = [PADDED]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [VAL]
+        }
+    "#;
+
+    let bytecode_left = common::compile_to_bytecode(source_left).unwrap();
+    // __LEFTPAD(0x42) produces 0x0000...0042 (left-padded to 32 bytes)
+    // Leading zeros are trimmed, so it's just 0x42
+    // PUSH1 = 0x60
+    assert_eq!(bytecode_left, "6042");
+}
+
+#[test]
+fn test_multiple_builtins_in_constants() {
+    let source = r#"
+        #define constant FUNC_SIG = __FUNC_SIG("transfer(address,uint256)")
+        #define constant EVENT_HASH = __EVENT_HASH("Transfer(address,address,uint256)")
+        #define constant SIG_REF = [FUNC_SIG]
+        #define constant HASH_REF = [EVENT_HASH]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [SIG_REF]
+            [HASH_REF]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // transfer(address,uint256) = 0xa9059cbb (PUSH4)
+    // Transfer(address,address,uint256) = 0xddf252ad... (PUSH32)
+    assert_eq!(bytecode, "63a9059cbb7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef");
+}
+
+#[test]
+fn test_error_selector_in_constant_reference() {
+    let source = r#"
+        #define error CustomError(uint256)
+
+        #define constant ERR = __FUNC_SIG(CustomError)
+        #define constant ERR_REF = [ERR]
+
+        #define macro MAIN() = takes(0) returns(0) {
+            [ERR_REF]
+        }
+    "#;
+
+    let bytecode = common::compile_to_bytecode(source).unwrap();
+    // CustomError(uint256) selector = keccak256("CustomError(uint256)")[0..4] = 0x110b3655
+    // PUSH4 = 0x63
+    assert_eq!(bytecode, "63110b3655");
+}