ZKML Prescripciones

# Verifica si el notebook está en Colab try: # Instala ezkl y onnx si estás en Colab  import google.colab import subprocess import sys subprocess.check_call([sys.executable, "-m", "pip", "install", "ezkl"]) subprocess.check_call([sys.executable, "-m", "pip", "install", "onnx"]) except: pass # Si no, usa tu setup de ezkl local  # Importa las librería necesarias from torch import nn import torch import ezkl import os # Convert a 3-byte hex number to tensor def hex_to_byte_tensor(hex_value): # Ensure the hex value is 6 characters (3 bytes) by padding with zeros  hex_str = f"{hex_value:06x}" return torch.tensor([int(hex_str[i:i+2], 16) for i in range(0, 6, 2)], dtype=torch.uint8) # Example input value (can be changed as needed) input_value = 0x047732 # This will be converted to [04, 77, 32] input_tensor = hex_to_byte_tensor(input_value) print(f"Input Tensor: {input_tensor}") # Example input value (can be changed as needed) input_value = 0x010402 # This will be converted to [04, 77, 32] input_tensor = hex_to_byte_tensor(input_value) print(f"Input Tensor: {input_tensor}") # Define a model that outputs the same 3 bytes that it receives as input class ThreeByteModel(nn.Module): def __init__(self): super(ThreeByteModel, self).__init__() def forward(self, x): # x should be a tensor of shape (batch_size, 3)  return x # Instancia el modelo circuit = ThreeByteModel() # Example input for the model dummy_input = input_tensor.unsqueeze(0) # Add batch dimension  # Generate output output = circuit(dummy_input) print(f"Output (3 bytes): {output}") # Export the model in Onnx format torch.onnx.export( circuit, dummy_input, "three_byte_model.onnx", input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}} ) print("Model saved as 'three_byte_model.onnx'!") 

import asyncio from torch import nn import ezkl import os import json import torch # Import the hex_to_byte_tensor function and ThreeByteModel from generate_model.py def hex_to_byte_tensor(hex_value): hex_str = f"{hex_value:06x}" return torch.tensor([int(hex_str[i:i+2], 16) for i in range(0, 6, 2)], dtype=torch.uint8) class ThreeByteModel(nn.Module): def __init__(self): super(ThreeByteModel, self).__init__() def forward(self, x): return x async def generate_contract(): circuit = ThreeByteModel() model_path = 'three_byte_model.onnx' compiled_model_path = 'three_byte_model.compiled' pk_path = 'test.pk' vk_path = 'test.vk' settings_path = 'settings.json' witness_path = 'witness.json' data_path = 'input.json' # Create input data  input_value = 0x040102 x = hex_to_byte_tensor(input_value) x = x.unsqueeze(0) # Add batch dimension  # Export the model  torch.onnx.export( circuit, x, model_path, export_params=True, opset_version=10, do_constant_folding=True, input_names=['input'], output_names=['output'], dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}} ) # Prepare input data for JSON  data_array = x.detach().numpy().reshape([-1]).tolist() data = dict(input_data=[data_array]) json.dump(data, open(data_path, 'w')) # Setup run arguments  py_run_args = ezkl.PyRunArgs() py_run_args.input_visibility = "public" py_run_args.output_visibility = "public" py_run_args.param_visibility = "fixed" # Generate settings  res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args) assert res == True # Calibrate settings  cal_path = "calibration.json" cal_data = dict(input_data=[x.detach().numpy().reshape([-1]).tolist()]) json.dump(cal_data, open(cal_path, 'w')) await ezkl.calibrate_settings(cal_path, model_path, settings_path, "resources") # Compile circuit  res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path) assert res == True # Get SRS  await ezkl.get_srs(settings_path) # Generate witness  res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path) assert os.path.isfile(witness_path) # Setup circuit  res = ezkl.setup(compiled_model_path, vk_path, pk_path) assert res == True # Generate proof  proof_path = 'test.pf' res = ezkl.prove(witness_path, compiled_model_path, pk_path, proof_path, "single") assert os.path.isfile(proof_path) # Verify proof  res = ezkl.verify(proof_path, settings_path, vk_path) assert res == True # Generate calldata  calldata = 'calldata.proof' res = ezkl.encode_evm_calldata(proof_path, calldata) calldata_hex = "0x" + ''.join(f"{byte:02x}" for byte in res) print("Calldata hex (EVM style):") print(calldata_hex) # Generate Solidity verifier  abi_path = 'test.abi' sol_code_path = 'test.sol' output_sol_path = 'verifier.sol' res = await ezkl.create_evm_verifier(vk_path, settings_path, sol_code_path, abi_path) assert res == True with open(sol_code_path, 'r') as source_file: with open(output_sol_path, 'w') as dest_file: dest_file.write(source_file.read()) print("Contract generated successfully!") return True async def main(): await generate_contract() if __name__ == "__main__": asyncio.run(main()) 

// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol"; interface Halo2Verifier { function verifyProof(bytes calldata proof, uint256[] calldata instances) external view; } contract PrescriptionVerifier is ERC1155 { address public immutable HALO2_VERIFIER; constructor(address halo2Verifier) ERC1155("https://raw.githubusercontent.com/Turupawn/VoidRxMetadata/refs/heads/main/{id}.json") { HALO2_VERIFIER = halo2Verifier; } function extractThreeUintsFromProof(bytes memory proofCalldata) public pure returns (uint256 a, uint256 b, uint256 c) { uint256 len = proofCalldata.length; // Extract values from proof (0 if position out of bounds) a = (len >= 1) ? uint256(uint8(proofCalldata[len - 1])) : 0; b = (len >= 33) ? uint256(uint8(proofCalldata[len - 33])) : 0; c = (len >= 65) ? uint256(uint8(proofCalldata[len - 65])) : 0; } function processPrescription(bytes memory proofCalldata) public { // Verify proof first (bool success, bytes memory data) = HALO2_VERIFIER.call(proofCalldata); require(success && data.length == 32 && uint8(data[31]) == 1, "Invalid proof"); // Extract medication amounts from proof (uint256 medA, uint256 medB, uint256 medC) = extractThreeUintsFromProof(proofCalldata); // Mint corresponding tokens to sender if (medA > 0) _mint(msg.sender, 1, medA, ""); if (medB > 0) _mint(msg.sender, 2, medB, ""); if (medC > 0) _mint(msg.sender, 3, medC, ""); } }