How to convert hex string to 256 bit number?

Mojo
1

Can anyone give me an example of code that converts a hex string to 256 bit number?

2

The user is asking about Mojo programming language and how to convert a hex string to a 256-bit number. This is a specific technical question about Mojo. Let me provide a clear example with explanation.

Here’s how you can convert a hex string to a 256-bit number in Mojo:

from sys import simdwidthof
from memory import memset_zero
from algorithm import vectorize

fn hex_char_to_int(c: Int8) -> Int:
    """Convert a single hex character to its integer value."""
    if c >= ord('0') and c <= ord('9'):
        return c - ord('0')
    elif c >= ord('a') and c <= ord('f'):
        return c - ord('a') + 10
    elif c >= ord('A') and c <= ord('F'):
        return c - ord('A') + 10
    else:
        return -1  # Invalid character

struct UInt256:
    """A 256-bit unsigned integer."""
    var data: SIMD[DType.uint64, 4]  # 4 x 64-bit = 256-bit
    
    fn __init__(inout self):
        self.data = SIMD[DType.uint64, 4](0)
    
    fn __init__(inout self, hex_string: String):
        """Initialize from a hex string."""
        self.data = SIMD[DType.uint64, 4](0)
        self.from_hex(hex_string)
    
    fn from_hex(inout self, hex_string: String):
        """Convert hex string to 256-bit number."""
        # Reset data
        self.data = SIMD[DType.uint64, 4](0)
        
        # Remove '0x' prefix if present
        var start_idx = 0
        if len(hex_string) >= 2:
            if hex_string[0] == '0' and (hex_string[1] == 'x' or hex_string[1] == 'X'):
                start_idx = 2
        
        # Process hex string from right to left
        var hex_len = len(hex_string) - start_idx
        var bit_position = 0
        
        # Process each hex character
        for i in range(hex_len):
            var char_idx = len(hex_string) - 1 - i
            var hex_value = hex_char_to_int(ord(hex_string[char_idx]))
            
            if hex_value < 0:
                print("Invalid hex character at position", char_idx)
                return
            
            # Determine which 64-bit word and bit position within that word
            var word_idx = bit_position // 64
            var bit_in_word = bit_position % 64
            
            if word_idx < 4:  # Ensure we don't overflow
                # Shift the hex value to the correct position and OR it in
                var shifted_value = UInt64(hex_value) << bit_in_word
                self.data[word_idx] |= shifted_value
            
            bit_position += 4  # Each hex digit is 4 bits
    
    fn to_hex(self) -> String:
        """Convert to hex string representation."""
        var result = String("0x")
        var found_nonzero = False
        
        # Process from most significant to least significant
        for i in range(4):
            var word_idx = 3 - i
            var word = self.data[word_idx]
            
            # Process each nibble (4 bits) in the word
            for j in range(16):
                var nibble_idx = 15 - j
                var nibble = (word >> (nibble_idx * 4)) & 0xF
                
                # Skip leading zeros unless we've found a non-zero
                if not found_nonzero and nibble == 0 and not (i == 3 and j == 15):
                    continue
                
                found_nonzero = True
                
                if nibble < 10:
                    result += chr(ord('0') + int(nibble))
                else:
                    result += chr(ord('a') + int(nibble) - 10)
        
        # Handle the case where the number is zero
        if not found_nonzero:
            result += "0"
        
        return result
    
    fn print_words(self):
        """Debug function to print internal representation."""
        print("256-bit number words (least significant first):")
        for i in range(4):
            print("  Word", i, ":", hex(int(self.data[i])))

fn main():
    # Example 1: Small hex number
    var num1 = UInt256("0xFF")
    print("Hex input: 0xFF")
    print("Converted back:", num1.to_hex())
    num1.print_words()
    print()
    
    # Example 2: Larger hex number
    var num2 = UInt256("0x123456789ABCDEF")
    print("Hex input: 0x123456789ABCDEF")
    print("Converted back:", num2.to_hex())
    num2.print_words()
    print()
    
    # Example 3: Full 256-bit number
    var num3 = UInt256("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
    print("Hex input: 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
    print("Converted back:", num3.to_hex())
    num3.print_words()
    print()
    
    # Example 4: Another 256-bit number
    var num4 = UInt256("0x1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF")
    print("Hex input: 0x1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF")
    print("Converted back:", num4.to_hex())
    num4.print_words()

Key points about this implementation:

  1. Storage: Uses SIMD[DType.uint64, 4] to store 256 bits (4 × 64-bit words)

  2. Hex Parsing:

    • Handles optional “0x” prefix
    • Processes hex string from right to left (least significant digit first)
    • Each hex character represents 4 bits

  3. Bit Manipulation:

    • Calculates which 64-bit word and bit position for each hex digit
    • Uses bitwise OR to combine values

  4. Error Handling: Validates hex characters and prevents overflow

  5. Conversion Back: The to_hex() method converts the 256-bit number back to a hex string for verification

For cryptographic applications, you might want to add additional methods like:

  • Arithmetic operations (add, subtract, multiply)
  • Bitwise operations (AND, OR, XOR, shift)
  • Comparison operations
  • Modular arithmetic for cryptography

This implementation provides a solid foundation for working with 256-bit numbers in Mojo, which is useful for applications like SHA-256 hashing, elliptic curve cryptography, or other scenarios requiring large integer arithmetic.

Hope this helps , it is by cluade chat fyi