fromHex

Create CallData from hex string

Creates CallData from a hex-encoded string. Specialized constructor for hex input with explicit validation.

Signature

Namespace

function fromHex(hex: string): CallDataType

Class

CallData.fromHex(hex: string): CallDataType

Parameters

• hex - Hex-encoded string (with or without 0x prefix)

Returns

CallDataType - Branded Uint8Array representing transaction calldata

Examples

Basic Usage

import { CallData } from '@tevm/voltaire';

// With 0x prefix
const calldata1 = CallData.fromHex("0xa9059cbb...");

// Without 0x prefix
const calldata2 = CallData.fromHex("a9059cbb...");

console.log(CallData.toHex(calldata1));
// "0xa9059cbb..."

Transaction Data

import { CallData } from '@tevm/voltaire';

const txData = "0xa9059cbb" +
  "00000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8" +
  "0000000000000000000000000000000000000000000000000de0b6b3a7640000";

const calldata = CallData.fromHex(txData);

console.log("Selector:", CallData.getSelector(calldata));
console.log("Size:", calldata.length, "bytes");
// Size: 68 bytes (4 + 32 + 32)

Namespace API

import * as CallData from '@tevm/voltaire/CallData';

const calldata = CallData.fromHex("0xa9059cbb...");
const selector = CallData.getSelector(calldata);

Validation

Validates hex string format:

import { CallData } from '@tevm/voltaire';

// Invalid hex characters
try {
  CallData.fromHex("0xGGGG");
} catch (error) {
  console.error("Invalid hex string");
}

// Odd length hex (must be byte-aligned)
try {
  CallData.fromHex("0xa9059c"); // 6 chars = 3 bytes = odd nibbles
} catch (error) {
  console.error("Hex must have even length");
}

// Too short (must be at least 4 bytes for selector)
try {
  CallData.fromHex("0xa905");
} catch (error) {
  console.error("CallData must be at least 4 bytes");
}

Comparison with from()

fromHex is more explicit but less flexible than from:

import { CallData } from '@tevm/voltaire';

// from() - Universal constructor
const calldata1 = CallData("0xa9059cbb...");
const calldata2 = CallData(new Uint8Array([0xa9, 0x05]));

// fromHex() - Hex string only
const calldata3 = CallData.fromHex("0xa9059cbb...");
const calldata4 = CallData.fromHex(bytes); // ❌ Type error

Use fromHex when:

• Input is always hex string
• You want explicit type checking
• Code clarity is prioritized

Use from when:

• Input type varies
• Maximum flexibility needed
• Writing generic functions

Use Cases

Parse Raw Transaction

import { CallData } from '@tevm/voltaire';

interface RawTransaction {
  data: string; // Hex string
}

function parseTxData(tx: RawTransaction) {
  const calldata = CallData.fromHex(tx.data);

  return {
    selector: CallData.getSelector(calldata),
    size: calldata.length,
  };
}

Validate Hex Input

import { CallData } from '@tevm/voltaire';

function isValidCallDataHex(hex: string): boolean {
  try {
    CallData.fromHex(hex);
    return true;
  } catch {
    return false;
  }
}

console.log(isValidCallDataHex("0xa9059cbb")); // true
console.log(isValidCallDataHex("0xGGGG")); // false

Type-Safe API

import { CallData } from '@tevm/voltaire';

// Enforce hex string input at API boundary
export function decodeCallData(hex: string) {
  const calldata = CallData.fromHex(hex); // Explicit hex validation
  return CallData.decode(calldata, abi);
}

Related

• from - Universal constructor
• fromBytes - From Uint8Array
• toHex - Convert to hex string
• isValid - Validate input