Verificando la Ejecución de RISC Zero En Un Contrato Inteligente de Stellar

RISC Zero ofrece un entorno de ejecución donde podemos computar grandes cantidades de datos fuera de la cadena y luego verificar el resultado en un contrato inteligente de Stellar. Esto tiene el potencial de expandir los límites de la computación descentralizada, así que abramos una ventana de consola y empecemos a verificar.

Necesitarás un entorno basado en Unix. Si estás en Windows, prueba Subsistema de Windows para Linux. También necesitarás Rust instalado y el stellar CLI.

Instalemos RISC Zero y configuremos un programa de ejemplo para verificar.
curl -L https://risczero.com/install | bash

rzup install

Una vez que lo tengamos en funcionamiento, clonemos el repositorio en:

git clone https://github.com/jamesbachini/RiscZero-Experiments.git

Dentro de este repositorio hay una aplicación RISC Zero llamada greater_than que tiene dos partes:

• El crate invitado es el código que se ejecutará dentro de la zkVM
• El crate anfitrión es el código que orquesta la generación de pruebas en tu máquina

Echemos un vistazo a la función principal dentro del programa invitado que se ejecuta en el anfitrión zkVM:

https://github.com/jamesbachini/RiscZero-Experiments/blob/main/greater_than/methods/guest/src/main.rs

fn main() {

let a: u32 = env::read();

let b: u32 = env::read();

if !(a > b) {

panic!("La condición falló: a no es mayor que b"); } env::commit(&1u32);

}

Aquí estamos leyendo dos variables numéricas u32 y luego verificando que a no sea mayor que b. Si lo es, entramos en pánico; si no, enviamos de vuelta un 1.

Luego tenemos la aplicación anfitriona para ejecutar esto, que se puede encontrar aquí: https://github.com/jamesbachini/RiscZero-Experiments/blob/main/greater_than/host/src/main.rs

Esto creará una prueba y producirá 3 valores al ejecutarse: println!("Sello (hex): {}", hex::encode(seal));println!("ID de imagen (hex): {}", hex::encode(image_id.as_bytes()));println!("SHA-256 del diario (hex): {}", hex::encode(journal_sha256.as_bytes()));

Son estos valores los que necesitamos para verificar la prueba dentro de un contrato inteligente de Stellar. Encendamos dockerd en segundo plano y luego ejecutemos el código.

sudo dockerd &

RISC0_DEV_MODE=0 cargo run --release

Después de un par de minutos, deberíamos obtener una salida algo así:

Ahora tenemos todo lo que necesitamos para verificar la prueba en un contrato inteligente de Stellar.

Procedamos y clonemos el contrato verificador de risc0 de Nethermind desde aquí:https://github.com/NethermindEth/stellar-risc0-verifier/

git clone https://github.com/NethermindEth/stellar-risc0-verifier.git

Ahora construyamos y despleguemos el contrato usando el CLI de Stellar.

Nota que necesitarás algo de XLM para enviar las transacciones, que puedes obtener para Testnet aquí: https://lab.stellar.org/account/fund?$=network$id=testnet

stellar contract build

stellar contract deploy --wasm target/wasm32v1-none/release/groth16_verifier.wasm --source james --network testnet

Una vez desplegado, se nos proporcionará un contractId que podemos usar para invocar llamadas a funciones. Llamaremos a la función selector, que devuelve un código hex de 4 bytes. Luego copiaremos y pegaremos este código hex de 4 bytes al principio del sello.

stellar contract invoke --network testnet --id CBY3GOBGQXDGRR4K2KYJO2UOXDW5NRW6UKIQHUBNBNU2V3BXQBXGTVX7 --source-account james -- selector

"73c457ba"
Utilicemos esto en la función principal de verificación, pasando el hash sha256 del diario, el id de imagen y el sello con el selector añadido al principio:

stellar contract invoke --network testnet --id CBY3GOBGQXDGRR4K2KYJO2UOXDW5NRW6UKIQHUBNBNU2V3BXQBXGTVX7 --source-account james --send=yes -- verify --journal 67abdd721024f0ff4e0b3f4c2fc13bc5bad42d0b7851d456d88d203d15aaa450 --image_id 9dee6122483cff892f04913c0d37f8ef1732f438551e204e11e9db56e27d3cd1 --seal 73c457ba0b6ef023f4714919283813c3163a85572756dd49f6413d6f2f8b91c59d6b6e3f1d6b36499f83c4cf1c51834fbd3cd67e116ad054a5497639c876eac501766e9007381ac060c447f25e4e848884533a7782524ce45b5b8aec784a8a201343d30b2da48ab647833bbe10418347723d678ea9267e51e62eb2d2397a4383759251842be67dd0fd700cb76a72d0e7a6e7d8e61376e88840bb5150013a949fe8ff2dd5252afef0ec3b47241cb0bbdf963571c20fbaca1858abd4175c8b6fef5a15fe881ac9a2871d734d27700603ce2c785c5f46f52c7a0196404475361496600a1f9604950eb367003d4c301a45eb32926e1ab9900b155058cc4af1f7392c11b159ec

Si la prueba Groth16 verifica, obtendrás una respuesta nula y sin pánicos. Esta es la manera en que el CLI de Stellar imprime () (unidad) ya que la función de verificación devuelve Result<(),VerifierError>

Este ejemplo básico debería ponerte en marcha. Lo bello de esto es que podrías probar en una sola transacción un cálculo complejo que involucre megabytes de datos, lo cual sería imposible de hacer directamente en la cadena.

Ese cálculo podría abrir nueva lógica dentro de un contrato inteligente descentralizado, creando nuevas posibilidades para los creadores que están desarrollando la próxima generación de tecnología de conocimiento cero en Stellar.

Para más información, consulta los siguientes recursos:

• https://dev.risczero.com/
• https://github.com/jamesbachini/RiscZero-Experiments
• https://github.com/risc0/risc0/tree/main/examples
• https://github.com/NethermindEth/stellar-risc0-verifier/tree/main