Funciones Nativas

Referencia de las 16 funciones globales disponibles sin importar.

Achronyme proporciona 16 funciones globales: 14 integradas en el núcleo de la VM, más 2 de la biblioteca estándar (achronyme-std). Todas están disponibles como globales — no necesitan importarse. Algunas también están disponibles en modo circuito.

Núcleo

print(...valores)

Imprime todos los argumentos separados por espacios, seguidos de un salto de línea. Devuelve nil.

print("hello", 42, true)  // hello 42 true

Modo: Solo VM

typeof(x)

Devuelve una cadena que describe el tipo del valor: "Number", "String", "Bool", "Nil", "List", "Map", "Field", "BigInt256", "BigInt512", "Proof", "Function", "Native".

typeof(42)      // "Number"
typeof("hi")    // "String"
typeof(true)    // "Bool"

Modo: Solo VM

assert(condicion)

Afirma que la condición es verdadera. Devuelve nil en caso de éxito, genera AssertionFailed en caso de fallo.

assert(1 + 1 == 2)  // ok
assert(false)        // error: AssertionFailed

Modo: Ambos (en circuitos, emite 2 restricciones: verificación booleana + forzar = 1)

time()

Devuelve la hora actual en milisegundos desde la época Unix.

let t = time()
print(t)  // 1740700800000

Modo: Solo VM

gc_stats()

Devuelve un mapa con estadísticas del recolector de basura. Ver Estadísticas del GC para más detalles.

let stats = gc_stats()
print(stats["collections"])     // número de ciclos de GC
print(stats["bytes_freed"])     // bytes recuperados acumulados
print(stats["peak_bytes"])      // tamaño máximo del heap alcanzado
print(stats["gc_time_ms"])      // ms acumulados en GC
print(stats["bytes_allocated"]) // tamaño actual del heap

Modo: Solo VM

Inspección de Pruebas

Estas funciones extraen componentes de un ProofObject devuelto por prove {}.

proof_json(prueba)

Devuelve la prueba Groth16 como una cadena JSON.

let p = prove { ... }
print(proof_json(p))  // {"pi_a": [...], "pi_b": [...], ...}

Modo: Solo VM

proof_public(prueba)

Devuelve las entradas públicas como una cadena JSON.

print(proof_public(p))  // ["21888...", "17159..."]

Modo: Solo VM

proof_vkey(prueba)

Devuelve la clave de verificación como una cadena JSON.

print(proof_vkey(p))  // {"protocol": "groth16", "curve": "bn128", ...}

Modo: Solo VM

Criptográficas

poseidon(izquierda, derecha)

Calcula el hash Poseidon 2-a-1 sobre BN254. Ambos argumentos pueden ser enteros o elementos de campo.

let h = poseidon(1, 2)
print(h)  // elemento de campo

Modo: Ambos (en circuitos, emite 361 restricciones)

poseidon_many(a, b, ...)

Hash Poseidon con plegado izquierdo: poseidon(poseidon(a, b), c) y así sucesivamente. Requiere al menos 2 argumentos.

let h = poseidon_many(1, 2, 3, 4)
// equivalente a: poseidon(poseidon(poseidon(1, 2), 3), 4)

Modo: Ambos (en circuitos, emite 361 restricciones por par)

verify_proof(prueba)

Verifica una prueba Groth16. Devuelve true si es válida, false en caso contrario. Requiere que un manejador de verificación esté configurado en la VM.

let p = prove { ... }
let ok = verify_proof(p)
print(ok)  // true

Modo: Solo VM

Constructores BigInt

bigint256(x)

Construye un entero sin signo de 256 bits desde un entero (>= 0) o cadena. Las cadenas pueden usar formato 0x (hex), 0b (binario) o decimal.

let a = bigint256(42)
let b = bigint256("0xFF")
let c = bigint256("12345")

Modo: Solo VM

bigint512(x)

Construye un entero sin signo de 512 bits. Mismos formatos de argumento que bigint256.

let a = bigint512(42)
let b = bigint512("0xFF")

Modo: Solo VM

from_bits(bits, ancho)

Construye un BigInt desde una lista de enteros 0/1 (LSB primero). El ancho debe ser 256 o 512.

let val = from_bits(bigint256(42).to_bits(), 256)
assert(val == bigint256(42))

Modo: Solo VM

Biblioteca Estándar

parse_int(str)

Parsea un string como entero. Error si el string no es un número válido.

parse_int("42")      // 42
parse_int("-7")      // -7

join(lista, separador)

Une una lista de strings con el separador dado.

join(["a", "b", "c"], "-")   // "a-b-c"
join(["hola"], " ")           // "hola"

Tabla Resumen