Introduce new builtin __BYTES() (#25)

* Introduce new builtin `__BYTES()`

* New release

Author: cakevm

CHANGELOG.md

@@ -4,6 +4,11 @@
 
 ## [Unreleased]
 
+## [1.0.7] - 2025-01-29
+- Add built-in macros for converting a string to bytes and push it to the stack.
+  - `__BYTES("hello")` -> `PUSH5 0x68656c6c6f`
+  - This can also be used here: `__RIGHTPAD(__BYTES("hello"))`.
+
 ## [1.0.6] - 2025-01-28
 - Allow to use `--debug` for reverting contracts.
 - Refactored parsing for ABI and build-in argument.

Cargo.lock

@@ -11,7 +11,7 @@ license = "MIT OR Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/cakevm/huff-neo"
 rust-version = "1.84"
-version = "1.0.6"
+version = "1.0.7"
 
 [workspace.dependencies]
 huff-neo-codegen = { path = "crates/codegen" }

Cargo.toml

@@ -31,9 +31,9 @@ pub fn bubble_arg_call(
                 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_string(l, false));
+                        tracing::info!(target: "codegen", "GOT LITERAL {} ARG FROM MACRO INVOCATION", bytes32_to_hex_string(l, false));
 
-                        let hex_literal: String = bytes32_to_string(l, false);
+                        let hex_literal: String = bytes32_to_hex_string(l, false);
                         let push_bytes = format!("{:02x}{hex_literal}", 95 + hex_literal.len() / 2);
                         let b = Bytes(push_bytes);
                         *offset += b.0.len() / 2;
@@ -91,7 +91,7 @@ pub fn bubble_arg_call(
                             tracing::info!(target: "codegen", "ARGCALL IS CONSTANT: {:?}", constant);
                             let push_bytes = match &constant.value {
                                 ConstVal::Literal(l) => {
-                                    let hex_literal: String = bytes32_to_string(l, false);
+                                    let hex_literal: String = bytes32_to_hex_string(l, false);
                                     format!("{:02x}{hex_literal}", 95 + hex_literal.len() / 2)
                                 }
                                 ConstVal::FreeStoragePointer(fsp) => {

crates/codegen/src/irgen/arg_calls.rs

@@ -1,7 +1,7 @@
 use crate::Codegen;
 use alloy_primitives::{hex, keccak256};
 use huff_neo_utils::bytecode::{BytecodeRes, Bytes, CircularCodeSizeIndices, Jump, Jumps};
-use huff_neo_utils::bytes_util::{bytes32_to_string, format_even_bytes, pad_n_bytes};
+use huff_neo_utils::bytes_util::{bytes32_to_hex_string, format_even_bytes, literal_gen, pad_n_bytes};
 use huff_neo_utils::error::{CodegenError, CodegenErrorKind};
 use huff_neo_utils::evm_version::EVMVersion;
 use huff_neo_utils::opcodes::Opcode;
@@ -98,7 +98,7 @@ pub fn builtin_function_gen<'a>(
             bytes.push((starting_offset, Bytes(push_bytes)));
         }
         BuiltinFunctionKind::RightPad => {
-            let push_bytes = right_pad(contract, bf)?;
+            let push_bytes = right_pad(evm_version, contract, bf)?;
             *offset += push_bytes.len() / 2;
             bytes.push((starting_offset, Bytes(push_bytes)));
         }
@@ -218,6 +218,11 @@ pub fn builtin_function_gen<'a>(
 
             bytes.push((starting_offset, Bytes(push_bytes)));
         }
+        BuiltinFunctionKind::Bytes => {
+            let push_bytes = builtin_bytes(evm_version, bf)?;
+            *offset += push_bytes.len() / 2;
+            bytes.push((starting_offset, Bytes(push_bytes)));
+        }
     }
     Ok(())
 }
@@ -373,7 +378,7 @@ fn tablesize(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<(TableDefi
         });
     };
 
-    let size = bytes32_to_string(&ir_table.size, false);
+    let size = bytes32_to_hex_string(&ir_table.size, false);
     let push_bytes = format!("{:02x}{size}", 95 + size.len() / 2);
     Ok((ir_table, push_bytes))
 }
@@ -402,7 +407,7 @@ fn event_hash(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<String, C
         });
     };
     let push_bytes = if let Some(event) = contract.events.iter().find(|e| first_arg.name.as_ref().unwrap().eq(&e.name)) {
-        let hash = bytes32_to_string(&event.hash, false);
+        let hash = bytes32_to_hex_string(&event.hash, false);
         format!("{}{hash}", Opcode::Push32)
     } else if let Some(s) = &first_arg.name {
         let event_selector = keccak256(s).0;
@@ -468,7 +473,7 @@ fn function_signature(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<S
     Ok(push_bytes)
 }
 
-fn right_pad(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<String, CodegenError> {
+fn right_pad(evm_version: &EVMVersion, contract: &Contract, bf: &BuiltinFunctionCall) -> Result<String, CodegenError> {
     if bf.args.len() != 1 {
         tracing::error!(target = "codegen", "Incorrect number of arguments passed to __RIGHTPAD, should be 1: {}", bf.args.len());
         return Err(CodegenError {
@@ -488,6 +493,10 @@ fn right_pad(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<String, Co
                     let push_bytes = function_signature(contract, inner_call)?;
                     push_bytes[2..].to_string() // remove opcode
                 }
+                BuiltinFunctionKind::Bytes => {
+                    let push_bytes = builtin_bytes(evm_version, inner_call)?;
+                    push_bytes[2..].to_string() // remove opcode
+                }
                 _ => {
                     tracing::error!(target: "codegen", "Invalid argument type passed to __RIGHTPAD");
                     return Err(CodegenError {
@@ -511,3 +520,50 @@ fn right_pad(contract: &Contract, bf: &BuiltinFunctionCall) -> Result<String, Co
     let push_bytes = format!("{}{hex}{}", Opcode::Push32, "0".repeat(64 - hex.len()));
     Ok(push_bytes)
 }
+
+fn builtin_bytes(evm_version: &EVMVersion, bf: &BuiltinFunctionCall) -> Result<String, CodegenError> {
+    if bf.args.len() != 1 {
+        tracing::error!(target = "codegen", "Incorrect number of arguments passed to __BYTES, should be 1: {}", bf.args.len());
+        return Err(CodegenError {
+            kind: CodegenErrorKind::InvalidArguments(format!(
+                "Incorrect number of arguments passed to __BYTES, should be 1: {}",
+                bf.args.len()
+            )),
+            span: bf.span.clone(),
+            token: None,
+        });
+    }
+    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(CodegenError {
+                kind: CodegenErrorKind::InvalidArguments(String::from("Invalid argument type passed to __BYTES")),
+                span: bf.span.clone(),
+                token: None,
+            });
+        }
+    };
+
+    if first_arg.is_empty() {
+        return Err(CodegenError {
+            kind: CodegenErrorKind::InvalidArguments(String::from("Empty string passed to __BYTES")),
+            span: bf.span.clone(),
+            token: None,
+        });
+    }
+
+    let bytes = first_arg.as_bytes();
+    if bytes.len() > 32 {
+        return Err(CodegenError {
+            kind: CodegenErrorKind::InvalidArguments(String::from("Encoded bytes length exceeds 32 bytes")),
+            span: bf.span.clone(),
+            token: None,
+        });
+    }
+    let mut bytes_array = [0u8; 32];
+    bytes_array[32 - bytes.len()..].copy_from_slice(bytes);
+
+    let push_bytes = literal_gen(evm_version, &bytes_array);
+    Ok(push_bytes)
+}

crates/codegen/src/irgen/builtin_function.rs

@@ -144,7 +144,7 @@ impl Codegen {
 
         res.utilized_tables.iter().try_for_each(|jt| {
             table_offsets.insert(jt.name.to_string(), table_offset);
-            let size = match bytes_util::hex_to_usize(bytes_util::bytes32_to_string(&jt.size, false).as_str()) {
+            let size = match bytes_util::hex_to_usize(bytes_util::bytes32_to_hex_string(&jt.size, false).as_str()) {
                 Ok(s) => s,
                 Err(e) => {
                     tracing::error!(target: "codegen", "Errored converting bytes32 to str. Bytes {:?} with error: {:?}", jt.size, e);

crates/codegen/src/lib.rs

@@ -659,7 +659,134 @@ fn test_builtin_rightpad_func_sig() {
 
     // Have Codegen create the runtime bytecode
     let r_bytes = Codegen::generate_main_bytecode(&EVMVersion::default(), &contract, None).unwrap();
-    // PUSH32 = 0x7f
-    // transfer(address,uint256) signature = 0xa9059cbb
+    // PUSH32 = 0x7f, transfer(address,uint256) signature = 0xa9059cbb
     assert_eq!(&r_bytes, "7fa9059cbb00000000000000000000000000000000000000000000000000000000");
 }
+
+#[test]
+fn test_builtin_rightpad_bytes() {
+    let source: &str = r#"
+        #define macro MAIN() = takes (0) returns (0) {
+            __RIGHTPAD(__BYTES('hello'))
+        }
+    "#;
+
+    // Parse tokens
+    let flattened_source = FullFileSource { source, file: None, spans: vec![] };
+    let lexer = Lexer::new(flattened_source);
+    let tokens = lexer.into_iter().map(|x| x.unwrap()).collect::<Vec<Token>>();
+    let mut parser = Parser::new(tokens, None);
+
+    // Parse the AST
+    let mut contract = parser.parse().unwrap();
+
+    // Derive storage pointers
+    contract.derive_storage_pointers();
+
+    // Instantiate Codegen
+    let cg = Codegen::new();
+
+    // The codegen instance should have no artifact
+    assert!(cg.artifact.is_none());
+
+    // Have Codegen create the runtime bytecode
+    let r_bytes = Codegen::generate_main_bytecode(&EVMVersion::default(), &contract, None).unwrap();
+    // PUSH32 = 0x7f, "hello" = 0x68656c6c6f
+    assert_eq!(&r_bytes, "7f68656c6c6f000000000000000000000000000000000000000000000000000000");
+}
+
+#[test]
+fn test_bytes_builtin() {
+    let source: &str = r#"
+        #define macro MAIN() = takes (0) returns (0) {
+            __BYTES("hello")
+            __BYTES("hellohello")
+            __BYTES("🙂🙂") // Will be represended as UTF-8 4-byte
+        }
+    "#;
+
+    // Parse tokens
+    let flattened_source = FullFileSource { source, file: None, spans: vec![] };
+    let lexer = Lexer::new(flattened_source);
+    let tokens = lexer.into_iter().map(|x| x.unwrap()).collect::<Vec<Token>>();
+    let mut parser = Parser::new(tokens, None);
+
+    // Parse the AST
+    let contract = parser.parse().unwrap();
+
+    // Instantiate Codegen
+    let cg = Codegen::new();
+
+    // The codegen instance should have no artifact
+    assert!(cg.artifact.is_none());
+
+    // Have Codegen create the runtime bytecode
+    let r_bytes = Codegen::generate_main_bytecode(&EVMVersion::default(), &contract, None).unwrap();
+    // 64 = PUSH5, "hello" = 0x68656c6c6f
+    assert_eq!(&r_bytes[0..12], "6468656c6c6f"); // 2 + 2 * 5 chars
+                                                 // 69 = PUSH10, "hellohello" = 0x68656c6c6f68656c6c6f
+    assert_eq!(&r_bytes[12..34], "6968656c6c6f68656c6c6f"); // 2 + 2 * 10 chars
+                                                            // 67 = PUSH8, "🙂🙂" = 0xf09f9982f09f9982
+    assert_eq!(&r_bytes[34..52], "67f09f9982f09f9982"); // 2 + 8 * 2 chars
+    assert_eq!(r_bytes.len(), (2 + 5 * 2) + (2 + 2 * 10) + (2 + 8 * 2));
+}
+
+#[test]
+fn test_bytes_builtin_too_large_error() {
+    let source: &str = r#"
+        #define macro MAIN() = takes (0) returns (0) {
+            __BYTES("hellohellohellohellohellohellohello") // 35 characters, codegen will fail
+        }
+    "#;
+
+    // Parse tokens
+    let flattened_source = FullFileSource { source, file: None, spans: vec![] };
+    let lexer = Lexer::new(flattened_source);
+    let tokens = lexer.into_iter().map(|x| x.unwrap()).collect::<Vec<Token>>();
+    let mut parser = Parser::new(tokens, None);
+
+    // Parse the AST
+    let contract = parser.parse().unwrap();
+
+    // Instantiate Codegen
+    let cg = Codegen::new();
+
+    // The codegen instance should have no artifact
+    assert!(cg.artifact.is_none());
+
+    // Codegen should fail with an error
+    let codegen_result = Codegen::generate_main_bytecode(&EVMVersion::default(), &contract, None);
+
+    assert!(codegen_result.is_err());
+    assert_eq!(codegen_result.unwrap_err().kind, CodegenErrorKind::InvalidArguments(String::from("Encoded bytes length exceeds 32 bytes")));
+}
+
+#[test]
+fn test_bytes_builtin_empty_string_error() {
+    let source: &str = r#"
+        #define macro MAIN() = takes (0) returns (0) {
+            __BYTES("")
+        }
+    "#;
+
+    // Parse tokens
+    let flattened_source = FullFileSource { source, file: None, spans: vec![] };
+    let lexer = Lexer::new(flattened_source);
+    let tokens = lexer.into_iter().map(|x| x.unwrap()).collect::<Vec<Token>>();
+    let mut parser = Parser::new(tokens, None);
+
+    // Parse the AST
+    let contract = parser.parse().unwrap();
+
+    // Instantiate Codegen
+    let cg = Codegen::new();
+
+    // The codegen instance should have no artifact
+    assert!(cg.artifact.is_none());
+
+    // Codegen should fail with an error
+    let codegen_result = Codegen::generate_main_bytecode(&EVMVersion::default(), &contract, None);
+
+    assert!(codegen_result.is_err());
+    assert_eq!(codegen_result.unwrap_err().kind, CodegenErrorKind::InvalidArguments(String::from("Empty string passed to __BYTES")));
+}