# Aztec-Sandbox ## Que es? En el ámbito de la ciberseguridad, un "sandbox" es un entorno virtual seguro y aislado diseñado para ejecutar programas o procesos de manera controlada, permitiendo analizar su comportamiento sin riesgo de dañar el sistema principal. Su objetivo es simular un entorno real sin comprometer la integridad del sistema. Aztec es una solución de capa 2 que aporta privacidad programable a la red Ethereum. Aztec Sandbox, por su parte, es una red de pruebas local creada para desarrolladores, enfocada en la privacidad de los contratos inteligentes. El lanzamiento de Aztec Sandbox representa un hito importante en la historia de Aztec Labs, marcando el primer gran avance hacia la culminación de Aztec: una capa 2 totalmente descentralizada que garantiza la privacidad. Aztec Sandbox ofrece una versión integral que proporciona a los desarrolladores un nodo Aztec local rápido y ligero, con funcionalidades similares a las ofrecidas por los paquetes de nodos locales Ganache o Anvil de Ethereum. ## Para que sirve? El Sandbox ayuda a los desarrolladores con visión de futuro a adquirir una ventaja inicial al interactuar con entornos blockchain nativos de ZK: Gestión de estado privado Modelos de abstracción de cuentas Comprender patrones para mantener la información privada de forma segura Rutas de ejecución de funciones privadas y públicas Y los ejemplos de contratos inteligentes de Aztec Labs incluyen una amplia gama de casos de uso que estamos ansiosos por ver: Contratos de tokens públicos y privados DeFi anónima Fuentes de precios de oráculos Distribuciones aéreas secretas Fideicomiso de dos partes Cuentas validadas de forma privada ## Cual es su valor agregado? Nuestra visión es crear un ecosistema financiero más justo y abierto, construido con la encriptación como su núcleo. Creemos que la descentralización se basa en los derechos individuales; sin una encriptación ampliamente accesible, comprometemos nuestra capacidad para elegir cómo vivimos nuestras vidas y ganamos nuestro sustento. Estamos construyendo la Red Aztec, un ZK-rollup completamente programable y privado en Ethereum para permitir a los desarrolladores crear aplicaciones descentralizadas con encriptación y escalabilidad. ## Establece el entorno Requisitos previos 1. Tener instalado [node >= 18](https://www.freecodecamp.org/espanol/news/como-instalar-node-js-en-macos-linux-o-windows-usando-nvm/) 2. Tener instalado [docker](https://docs.docker.com/desktop/install/mac-install/) 3. Tener instalado [yarn](https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable) globalmente \*\* Nota: Ya que el lenguaje de programacion de Aztec es basado en [Noir](https://noir-lang.org/), te recomiendo que instales el plugin de Noir en tu Visual Studio Code. [Ref](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir#:~:text=This%20extension%20helps%20developers%20write,via%20codelens%20above%20each%20test) ## Establece tu entorno de desarrollo 1. Verificamos que tenemos instalado node >= 18 ``` node -v ``` 2. Verificamos que tenemos instalado docker ``` docker -v ``` 3. Creamos un nuevo proyecto a partir de la linea de comandos ``` npm create aztec-app ``` 4. Selecionamos “just contract example” en caso que querramos crear solamente el contrato, o seleccionamos Boilerplate project with frontend en caso que necesitemos incluir el frontend. ![\*](https://images.mirror-media.xyz/publication-images/x26J5qKAtji0wCf6lUL0K.png?height=530&width=1144) 5\. Seleccionar el tipo de formato de el frontend que prefieras y escribe el nombre de tu proyecto. ![\*](https://images.mirror-media.xyz/publication-images/Z1_0MVHVi0z-vbo6-OjrU.png?height=150&width=1150) 6\. Seguidamente si no tienes descargadas las imagenes de docker de aztec, te consultara si deseas descargarla, presiona y o enter. ![](https://images.mirror-media.xyz/publication-images/xiz-XYCVy1av-QJCdr1H6.png?height=398&width=1138) \*\* Puede tomar un par de minutos. ![](https://images.mirror-media.xyz/publication-images/7YdEalZObYDCoQroo4W01.png?height=728&width=1150) 7\. Una vez descagado las imagener de los contenedors, te preguntara si desea correr el servidar, seleccionaremos que si. 1. \*\* El servidor se levantara en el puerto 8080, puedes cambiar el puerto modificando el archivo docker-compose.yml de la imagen ó puedes desocupar el puerto matando los procesos que estan en ese puerto. ``` kill -9 $(lsof -ti:3000) ``` ![](https://images.mirror-media.xyz/publication-images/jRHbOjK8_WobHlxPcY-XE.png?height=740&width=1134) ![](https://images.mirror-media.xyz/publication-images/ei5XrYX6xVQBcyE0TszSG.png?height=680&width=1144) 8\. Instalamos dependencias y levantamos el servidor web. 8\.1 Ya que la ultima version estable de yarm no es compatible con la estipulada en nuestro package.json, eliminaremos el ‘packageManager’ de nuestro archivo package json. Para que tome la version yarn global de su ordenador. ![](https://images.mirror-media.xyz/publication-images/OjNFvCccLiF4Oul647Ax1.png?height=982&width=1082) 8\.2 Instalamos dependencias ``` $ yarn install ``` 8\.3 Corremos el servidor web ``` $ yarn dev ``` ![](https://images.mirror-media.xyz/publication-images/vmejMsleieSw5K5Vzesfr.png?height=1298&width=2916) ![\*](https://images.mirror-media.xyz/publication-images/Qo5IIRzNf4OOZHf55-zKr.png?height=982&width=1982) ``` $ aztec-sandbox ``` ![](https://images.mirror-media.xyz/publication-images/2dxLcr9WJPmiO4l0vnMca.png?height=1028&width=2458) ## Ejercicio Practico: Contrato de tokens con Aztec. #### Que es un contrato de token? ![Un token es cualquier active digital, Ejemplos: criptomonedas, tokens de utilidad, tokens de seguridad o activos digitales fungibles y no fungibles.](https://images.mirror-media.xyz/publication-images/Rm2svUINsfUPzPlidIDeH.png?height=1092&width=1950) * Modificaremos el contrato que viene por defecto en la ruta: ![](https://images.mirror-media.xyz/publication-images/FJq0BD-5KPUtFzyi0xVl2.png?height=204&width=494) ``` mod types; // Minimal token implementation that supports `AuthWit` accounts. // The auth message follows a similar pattern to the cross-chain message and includes a designated caller. // The designated caller is ALWAYS used here, and not based on a flag as cross-chain. // message hash = H([caller, contract, selector, ...args]) // To be read as `caller` calls function at `contract` defined by `selector` with `args` // Including a nonce in the message hash ensures that the message can only be used once. contract Token { use dep::compressed_string::FieldCompressedString; use dep::aztec::prelude::{ NoteGetterOptions, NoteHeader, Map, PublicMutable, SharedImmutable, PrivateSet, FunctionSelector, AztecAddress }; use dep::aztec::hash::compute_secret_hash; use dep::authwit::{auth::{assert_current_call_valid_authwit, assert_current_call_valid_authwit_public}}; use crate::types::{transparent_note::TransparentNote, token_note::{TokenNote, TOKEN_NOTE_LEN}, balances_map::BalancesMap}; #[aztec(storage)] struct Storage { admin: PublicMutable, minters: Map>, balances: BalancesMap, total_supply: PublicMutable, pending_shields: PrivateSet, public_balances: Map>, symbol: SharedImmutable, name: SharedImmutable, decimals: SharedImmutable, } #[aztec(public)] #[aztec(initializer)] fn constructor(admin: AztecAddress, name: str<31>, symbol: str<31>, decimals: u8) { assert(!admin.is_zero(), "invalid admin"); storage.admin.write(admin); storage.minters.at(admin).write(true); storage.name.initialize(FieldCompressedString::from_string(name)); storage.symbol.initialize(FieldCompressedString::from_string(symbol)); storage.decimals.initialize(decimals); } #[aztec(public)] fn set_admin(new_admin: AztecAddress) { assert(storage.admin.read().eq(context.msg_sender()), "caller is not admin"); storage.admin.write(new_admin); } #[aztec(public)] fn set_minter(minter: AztecAddress, approve: bool) { assert(storage.admin.read().eq(context.msg_sender()), "caller is not admin"); storage.minters.at(minter).write(approve); } #[aztec(public)] fn mint_public(to: AztecAddress, amount: Field) { assert(storage.minters.at(context.msg_sender()).read(), "caller is not minter"); let amount = U128::from_integer(amount); let new_balance = storage.public_balances.at(to).read().add(amount); let supply = storage.total_supply.read().add(amount); storage.public_balances.at(to).write(new_balance); storage.total_supply.write(supply); } #[aztec(public)] fn mint_private(amount: Field, secret_hash: Field) { assert(storage.minters.at(context.msg_sender()).read(), "caller is not minter"); let pending_shields = storage.pending_shields; let mut note = TransparentNote::new(amount, secret_hash); let supply = storage.total_supply.read().add(U128::from_integer(amount)); storage.total_supply.write(supply); pending_shields.insert_from_public(&mut note); } #[aztec(public)] fn shield(from: AztecAddress, amount: Field, secret_hash: Field, nonce: Field) { if (!from.eq(context.msg_sender())) { assert_current_call_valid_authwit_public(&mut context, from); } else { assert(nonce == 0, "invalid nonce"); } let amount = U128::from_integer(amount); let from_balance = storage.public_balances.at(from).read().sub(amount); let pending_shields = storage.pending_shields; let mut note = TransparentNote::new(amount.to_integer(), secret_hash); storage.public_balances.at(from).write(from_balance); pending_shields.insert_from_public(&mut note); } #[aztec(public)] fn transfer_public(from: AztecAddress, to: AztecAddress, amount: Field, nonce: Field) { if (!from.eq(context.msg_sender())) { assert_current_call_valid_authwit_public(&mut context, from); } else { assert(nonce == 0, "invalid nonce"); } let amount = U128::from_integer(amount); let from_balance = storage.public_balances.at(from).read().sub(amount); storage.public_balances.at(from).write(from_balance); let to_balance = storage.public_balances.at(to).read().add(amount); storage.public_balances.at(to).write(to_balance); } #[aztec(public)] fn burn_public(from: AztecAddress, amount: Field, nonce: Field) { if (!from.eq(context.msg_sender())) { assert_current_call_valid_authwit_public(&mut context, from); } else { assert(nonce == 0, "invalid nonce"); } let amount = U128::from_integer(amount); let from_balance = storage.public_balances.at(from).read().sub(amount); storage.public_balances.at(from).write(from_balance); let new_supply = storage.total_supply.read().sub(amount); storage.total_supply.write(new_supply); } #[aztec(private)] fn redeem_shield(to: AztecAddress, amount: Field, secret: Field) { let pending_shields = storage.pending_shields; let secret_hash = compute_secret_hash(secret); let mut options = NoteGetterOptions::new(); options = options.select(TransparentNote::properties().amount, amount, Option::none()).select( TransparentNote::properties().secret_hash, secret_hash, Option::none() ).set_limit(1); let notes = pending_shields.get_notes(options); let note = notes[0].unwrap_unchecked(); pending_shields.remove(note); storage.balances.add(to, U128::from_integer(amount)); } #[aztec(private)] fn unshield(from: AztecAddress, to: AztecAddress, amount: Field, nonce: Field) { if (!from.eq(context.msg_sender())) { assert_current_call_valid_authwit(&mut context, from); } else { assert(nonce == 0, "invalid nonce"); } storage.balances.sub(from, U128::from_integer(amount)); let selector = FunctionSelector::from_signature("_increase_public_balance((Field),Field)"); let _void = context.call_public_function(context.this_address(), selector, [to.to_field(), amount]); } #[aztec(private)] fn transfer(from: AztecAddress, to: AztecAddress, amount: Field, nonce: Field) { if (!from.eq(context.msg_sender())) { assert_current_call_valid_authwit(&mut context, from); } else { assert(nonce == 0, "invalid nonce"); } let amount = U128::from_integer(amount); storage.balances.sub(from, amount); storage.balances.add(to, amount); } #[aztec(private)] fn burn(from: AztecAddress, amount: Field, nonce: Field) { if (!from.eq(context.msg_sender())) { assert_current_call_valid_authwit(&mut context, from); } else { assert(nonce == 0, "invalid nonce"); } storage.balances.sub(from, U128::from_integer(amount)); let selector = FunctionSelector::from_signature("_reduce_total_supply(Field)"); let _void = context.call_public_function(context.this_address(), selector, [amount]); } #[aztec(public)] #[aztec(internal)] fn _increase_public_balance(to: AztecAddress, amount: Field) { let new_balance = storage.public_balances.at(to).read().add(U128::from_integer(amount)); storage.public_balances.at(to).write(new_balance); } #[aztec(public)] #[aztec(internal)] fn _reduce_total_supply(amount: Field) { let new_supply = storage.total_supply.read().sub(U128::from_integer(amount)); storage.total_supply.write(new_supply); } unconstrained fn admin() -> pub Field { storage.admin.read().to_field() } unconstrained fn is_minter(minter: AztecAddress) -> pub bool { storage.minters.at(minter).read() } unconstrained fn total_supply() -> pub Field { storage.total_supply.read().to_integer() } unconstrained fn balance_of_private(owner: AztecAddress) -> pub Field { storage.balances.balance_of(owner).to_integer() } unconstrained fn balance_of_public(owner: AztecAddress) -> pub Field { storage.public_balances.at(owner).read().to_integer() } // Function fails #[aztec(public)] fn public_get_name() { storage.name.read_public() } #[aztec(private)] fn private_get_name() { storage.name.read_private() } #[aztec(public)] fn public_get_symbol() { storage.symbol.read_public() } #[aztec(private)] fn private_get_symbol() { storage.symbol.read_private() } #[aztec(public)] fn public_get_decimals() { // docs:start:read_decimals_public storage.decimals.read_public() // docs:end:read_decimals_public } #[aztec(private)] fn private_get_decimals() { // docs:start:read_decimals_private storage.decimals.read_private() // docs:end:read_decimals_private } unconstrained fn un_get_symbol() -> pub [u8; 31] { storage.symbol.read_public().to_bytes() } unconstrained fn un_get_name() -> pub [u8; 31] { storage.name.read_public().to_bytes() } unconstrained fn un_get_decimals() -> pub u8 { storage.decimals.read_public() } } ``` * Creamos una carpeta donde definiremos el tipado de las clases, funciones y variables. * Archivo src/types/balances_map.nr ``` use dep::aztec::prelude::{ AztecAddress, NoteGetterOptions, NoteViewerOptions, NoteHeader, NoteInterface, PrivateContext, PrivateSet, Map, emit_encrypted_log }; use dep::aztec::{ context::{PublicContext, Context}, hash::pedersen_hash, protocol_types::constants::MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, note::{note_getter::view_notes, note_getter_options::SortOrder} }; use crate::types::token_note::{TokenNote, OwnedNote}; struct BalancesMap { map: Map> } impl BalancesMap { pub fn new(context: Context, storage_slot: Field) -> Self { assert(storage_slot != 0, "Storage slot 0 not allowed. Storage slots must start from 1."); Self { map: Map::new( context, storage_slot, |context, slot| PrivateSet::new(context, slot) ) } } unconstrained pub fn balance_of( self: Self, owner: AztecAddress ) -> U128 where T: NoteInterface + OwnedNote { self.balance_of_with_offset(owner, 0) } unconstrained pub fn balance_of_with_offset( self: Self, owner: AztecAddress, offset: u32 ) -> U128 where T: NoteInterface + OwnedNote { let mut balance = U128::from_integer(0); // docs:start:view_notes let mut options = NoteViewerOptions::new(); let opt_notes = self.map.at(owner).view_notes(options.set_offset(offset)); // docs:end:view_notes let len = opt_notes.len(); for i in 0..len { if opt_notes[i].is_some() { balance = balance + opt_notes[i].unwrap_unchecked().get_amount(); } } if (opt_notes[len - 1].is_some()) { balance = balance + self.balance_of_with_offset(owner, offset + opt_notes.len() as u32); } balance } pub fn add( self: Self, owner: AztecAddress, addend: U128 ) where T: NoteInterface + OwnedNote { let mut addend_note = T::new(addend, owner); // docs:start:insert self.map.at(owner).insert(&mut addend_note, true); // docs:end:insert } pub fn sub( self: Self, owner: AztecAddress, subtrahend: U128 ) where T: NoteInterface + OwnedNote { // docs:start:get_notes let options = NoteGetterOptions::with_filter(filter_notes_min_sum, subtrahend); let maybe_notes = self.map.at(owner).get_notes(options); // docs:end:get_notes let mut minuend: U128 = U128::from_integer(0); for i in 0..maybe_notes.len() { if maybe_notes[i].is_some() { let note = maybe_notes[i].unwrap_unchecked(); // Removes the note from the owner's set of notes. // This will call the the `compute_nullifer` function of the `token_note` // which require knowledge of the secret key (currently the users encryption key). // The contract logic must ensure that the spending key is used as well. // docs:start:remove self.map.at(owner).remove(note); // docs:end:remove minuend = minuend + note.get_amount(); } } // This is to provide a nicer error msg, // without it minuend-subtrahend would still catch it, but more generic error then. // without the == true, it includes 'minuend.ge(subtrahend)' as part of the error. assert(minuend >= subtrahend, "Balance too low"); self.add(owner, minuend - subtrahend); } } pub fn filter_notes_min_sum( notes: [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL], min_sum: U128 ) -> [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] where T: NoteInterface + OwnedNote { let mut selected = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL]; let mut sum = U128::from_integer(0); for i in 0..notes.len() { if notes[i].is_some() & sum < min_sum { let note = notes[i].unwrap_unchecked(); selected[i] = Option::some(note); sum = sum.add(note.get_amount()); } } selected } ``` * Archivo src/types/token_note.nr ``` use dep::aztec::prelude::{ AztecAddress, NoteInterface, NoteGetterOptions, NoteViewerOptions, NoteHeader, PrivateContext, PrivateSet, Map, emit_encrypted_log }; use dep::aztec::{note::utils::compute_note_hash_for_consumption, hash::pedersen_hash}; use dep::aztec::oracle::{unsafe_rand::unsafe_rand, nullifier_key::get_nullifier_secret_key, get_public_key::get_public_key}; trait OwnedNote { fn new(amount: U128, owner: AztecAddress) -> Self; fn get_amount(self) -> U128; fn get_owner(self) -> AztecAddress; } global TOKEN_NOTE_LEN: Field = 3; // 3 plus a header. #[aztec(note)] struct TokenNote { // the amount of tokens in the note amount: U128, // the provider of secrets for the nullifier. The owner (recipient) to ensure that the note // can be privately spent. When nullifier secret and encryption private key is same // we can simply use the owner for this one. owner: AztecAddress, // randomness of the note to hide contents. randomness: Field, } impl NoteInterface for TokenNote { // docs:start:nullifier fn compute_nullifier(self, context: &mut PrivateContext) -> Field { let note_hash_for_nullify = compute_note_hash_for_consumption(self); let secret = context.request_nullifier_secret_key(self.owner); // TODO(#1205) Should use a non-zero generator index. pedersen_hash([ note_hash_for_nullify, secret.low, secret.high, ],0) } // docs:end:nullifier fn compute_nullifier_without_context(self) -> Field { let note_hash_for_nullify = compute_note_hash_for_consumption(self); let secret = get_nullifier_secret_key(self.owner); // TODO(#1205) Should use a non-zero generator index. pedersen_hash([ note_hash_for_nullify, secret.low, secret.high, ],0) } // Broadcasts the note as an encrypted log on L1. fn broadcast(self, context: &mut PrivateContext, slot: Field) { // We only bother inserting the note if non-empty to save funds on gas. if !(self.amount == U128::from_integer(0)) { let encryption_pub_key = get_public_key(self.owner); emit_encrypted_log( context, (*context).this_address(), slot, Self::get_note_type_id(), encryption_pub_key, self.serialize_content(), ); } } } impl OwnedNote for TokenNote { fn new(amount: U128, owner: AztecAddress) -> Self { Self { amount, owner, randomness: unsafe_rand(), header: NoteHeader::empty(), } } fn get_amount(self) -> U128 { self.amount } fn get_owner(self) -> AztecAddress { self.owner } } ``` * Archivo src/types/transparent_note.nr ``` // docs:start:token_types_all use dep::aztec::prelude::{NoteHeader, NoteInterface, PrivateContext}; use dep::aztec::{ note::{note_getter_options::PropertySelector, utils::compute_note_hash_for_consumption}, hash::{compute_secret_hash, pedersen_hash} }; global TRANSPARENT_NOTE_LEN: Field = 2; // Transparent note represents a note that is created in the clear (public execution), // but can only be spent by those that know the preimage of the "secret_hash" #[aztec(note)] struct TransparentNote { amount: Field, secret_hash: Field, // the secret is just here for ease of use and won't be (de)serialized secret: Field } struct TransparentNoteProperties { amount: PropertySelector, secret_hash: PropertySelector, } impl NoteInterface for TransparentNote { // Custom serialization to avoid disclosing the secret field fn serialize_content(self) -> [Field; TRANSPARENT_NOTE_LEN] { [self.amount, self.secret_hash] } // Custom deserialization since we don't have access to the secret plaintext fn deserialize_content(serialized_note: [Field; TRANSPARENT_NOTE_LEN]) -> Self { TransparentNote { amount: serialized_note[0], secret_hash: serialized_note[1], secret: 0, header: NoteHeader::empty(), } } fn compute_nullifier(self, _context: &mut PrivateContext) -> Field { self.compute_nullifier_without_context() } fn compute_nullifier_without_context(self) -> Field { let siloed_note_hash = compute_note_hash_for_consumption(self); // TODO(#1205) Should use a non-zero generator index. pedersen_hash([self.secret, siloed_note_hash],0) } fn broadcast(self, context: &mut PrivateContext, slot: Field) { assert(false, "TransparentNote does not support broadcast"); } } impl TransparentNote { // CONSTRUCTORS pub fn new(amount: Field, secret_hash: Field) -> Self { TransparentNote { amount, secret_hash, secret: 0, header: NoteHeader::empty() } } // new oracle call primitive // get me the secret corresponding to this hash pub fn new_from_secret(amount: Field, secret: Field) -> Self { TransparentNote { amount, secret_hash: compute_secret_hash(secret), secret, header: NoteHeader::empty() } } // CUSTOM FUNCTIONS FOR THIS NOTE TYPE pub fn knows_secret(self, secret: Field) { let hash = compute_secret_hash(secret); assert(self.secret_hash == hash); } // Custom serialization forces us to manually create the metadata struct and its getter pub fn properties() -> TransparentNoteProperties { TransparentNoteProperties { amount: PropertySelector { index: 0, offset: 0, length: 32 }, secret_hash: PropertySelector { index: 1, offset: 0, length: 32 } } } } // docs:end:token_types_all ``` * Creamos un archivo types.nr donde inportaremos y a su vez exportaremos los types que definimos en la carpeta, esto con el objetivo de centralizar el tipado atravez de un solo archivo * Archivo src/types.nr ``` mod transparent_note; mod balances_map; mod token_note; ``` * Actualizamos el archivo Nargo.toml con las dependencias ``` [package] name = "token_contract" authors = [ "" ] compiler_version = ">=0.25.0" type = "contract" [dependencies] aztec = { git="https://github.com/AztecProtocol/aztec-packages/", tag="aztec-packages-v0.35.1", directory="noir-projects/aztec-nr/aztec" } authwit={ git="https://github.com/AztecProtocol/aztec-packages/", tag="aztec-packages-v0.35.1", directory="noir-projects/aztec-nr/authwit"} compressed_string = {git="https://github.com/AztecProtocol/aztec-packages/", tag="aztec-packages-v0.35.1", directory="noir-projects/aztec-nr/compressed-string"} ``` * Compile the smart contract. ``` yarn compile ``` ### Integrando la interfaz de usuario Vamos a crear una interfaz sencilla semejante al siguiente mockup: ![](https://images.mirror-media.xyz/publication-images/Se9xgz75KICG-SWXQycAx.png?height=584&width=824) * Creamos un hook src/hooks/useToken.tsx * ``` import { useState } from 'react'; import { Contract } from '@aztec/aztec.js'; import { deployerEnv } from '../config'; import { toast } from 'react-toastify'; export function useToken({ contract }: { contract: Contract }) { const [wait, setWait] = useState(false); const setAdmin = async (e: React.FormEvent) => { e.preventDefault(); const el = e.currentTarget.elements.namedItem('admin') as HTMLInputElement; if (el) { setWait(true); const address = el.value; await toast.promise(contract!.methods.set_admin(BigInt(address)).send().wait(), { pending: 'Setting ...', success: `Admin set: ${address}`, error: 'Error setting admin', }); setWait(false); } }; const setMinter = async (e: React.FormEvent) => { e.preventDefault(); const address = (e.currentTarget.elements.namedItem('minter') as HTMLInputElement).value; const approve = (e.currentTarget.elements.namedItem('approve') as HTMLInputElement).value; if (address && approve) { setWait(true); await toast.promise(contract!.methods.set_minter(BigInt(address), approve).send().wait(), { pending: 'Setting ...', success: `Minter set: ${address}`, error: 'Error setting admin', }); setWait(false); } }; const mintPublic = async (e: React.FormEvent) => { e.preventDefault(); const address = (e.currentTarget.elements.namedItem('minter') as HTMLInputElement).value; const amount = (e.currentTarget.elements.namedItem('amount') as HTMLInputElement).value; if (address && amount) { setWait(true); await toast.promise(contract!.methods.mint_public(BigInt(address), amount).send().wait(), { pending: 'Setting ...', success: `Process success`, error: 'Error setting admin', }); setWait(false); } }; const mintPrivate = async (e: React.FormEvent) => { e.preventDefault(); const amount = (e.currentTarget.elements.namedItem('amount') as HTMLInputElement).value; const secret = (e.currentTarget.elements.namedItem('secretHash') as HTMLInputElement).value; if (amount && secret) { setWait(true); await toast.promise(contract!.methods.mint_private(amount, secret).send().wait(), { pending: 'Setting ...', success: `Process Success`, error: 'Error setting admin', }); setWait(false); } }; const shield = async (e: React.FormEvent) => { // from: AztecAddress, amount: Field, secret_hash: Field, nonce: Field e.preventDefault(); const amount = (e.currentTarget.elements.namedItem('amount') as HTMLInputElement).value; const from = (e.currentTarget.elements.namedItem('from') as HTMLInputElement).value; const secret = (e.currentTarget.elements.namedItem('secretHash') as HTMLInputElement).value; const nonce = (e.currentTarget.elements.namedItem('nonce') as HTMLInputElement).value; if (amount && secret && from && nonce) { setWait(true); await toast.promise(contract!.methods.shield(BigInt(from), BigInt(amount), secret, nonce).send().wait(), { pending: 'Setting ...', success: `Process Success`, error: 'Error setting admin', }); setWait(false); } }; const transferPublic = async (e: React.FormEvent) => { // transfer_public(from: AztecAddress, to: AztecAddress, amount: Field, nonce: Field) e.preventDefault(); const amount = (e.currentTarget.elements.namedItem('amount') as HTMLInputElement).value; const from = (e.currentTarget.elements.namedItem('from') as HTMLInputElement).value; const to = (e.currentTarget.elements.namedItem('to') as HTMLInputElement).value; const nonce = (e.currentTarget.elements.namedItem('nonce') as HTMLInputElement).value; if (amount && from && to && nonce) { setWait(true); await toast.promise( contract!.methods.transfer_public(BigInt(from), BigInt(to), BigInt(amount), nonce).send().wait(), { pending: 'Setting ...', success: `Process Success`, error: 'Error setting admin', }, ); setWait(false); } }; const burnPublic = async (e: React.FormEvent) => { // burn_public(from: AztecAddress, amount: Field, nonce: Field) e.preventDefault(); const amount = (e.currentTarget.elements.namedItem('amount') as HTMLInputElement).value; const from = (e.currentTarget.elements.namedItem('from') as HTMLInputElement).value; const nonce = (e.currentTarget.elements.namedItem('nonce') as HTMLInputElement).value; if (amount && from && nonce) { setWait(true); await toast.promise(contract!.methods.burn_public(BigInt(from), BigInt(amount), nonce).send().wait(), { pending: 'Setting ...', success: `Process Success`, error: 'Error setting admin', }); setWait(false); } }; return { setAdmin, setMinter, mintPublic, mintPrivate, shield, transferPublic, burnPublic, wait }; } ``` * Creamos el UI con los formularios que nos ayudaran a interactuar con nuestro contrato de token. src/pages/contract.tsx ``` import { useState } from 'react'; import { Contract } from '@aztec/aztec.js'; import { filteredInterface } from '../config'; import { useToken } from '../hooks/useToken'; export function ContractComponent({ contract }: { contract: Contract }) { const { wait, setAdmin, setMinter, mintPublic, mintPrivate, shield, transferPublic, burnPublic } = useToken({ contract, }); return (

Your Contract

Functions:

Set Admin

Set Minter

Mint Public

Mint Private

Shield

Transfer Public

Burn Public

); } ``` ### Referencia: Documentacion oficial \[Aztec-sandbox\]( ) Tutorial \[Contrato de tokens\]( ) Documentacion oficial Noir: ### Pequeños retos para experimentar:

0xe527

0xe527

AZTEC-SANDBOX