Módulos y biblioteca estándar

La versión 2 del lenguaje separa dos ideas fáciles de confundir:

En resumen: un módulo se copia dentro de su contrato; un contrato se llama. Elija un módulo para reutilizar código y otro contrato para compartir estado o fondos con otras aplicaciones.

Usar un módulo estándar#

contract CloudCoin
use std.token

role minter

init(supply: int):
    token.setup("Cloud Coin", "CLD", 8)
    grant minter to caller
    token.mint(caller, supply)

action mint(to: address, amount: int) only minter:
    token.mint(to, amount)

• use std.token compila el módulo de token estándar dentro de CloudCoin. use std.token as coin elige otro nombre.
• Las funciones auxiliares del módulo se llaman con su nombre: token.mint(to, amount).
• Las actions y views del módulo pasan a formar parte de la interfaz del contrato: CloudCoin ahora tiene transfer, approve, transfer_from, balance_of y las demás. Un choque de nombres con el contrato es un error de compilación.
• El estado del módulo se guarda dentro del contrato con nombres calificados (token.balances). El contrato puede leerlo (token.total_supply), pero solo las funciones del módulo pueden cambiarlo — así las reglas del módulo (saldos nunca negativos, oferta igual a la suma de saldos) se mantienen hagan lo que haga el contrato.
• Los records y enums del módulo se llaman token.Record desde el contrato.

Sus propios módulos#

Ponga secciones module al final del archivo:

contract App
use mathx

view average(a: int, b: int) -> int:
    return mathx.mean(a, b)

module mathx
fn mean(a: int, b: int) -> int:
    return (a + b) / 2

O guarde el módulo en mathx.tccl junto al contrato (empezando con module mathx). tccl check, tccl run y tccl test lo encuentran solos, y tccl bundle app.tccl -o deploy.tccl escribe el archivo único que despliega: un despliegue siempre lleva un solo archivo de código.

Un módulo puede declarar constantes, records, enums, interfaces, eventos, estado, roles, auxiliares fn, actions y views. No puede declarar init() ni upgrade() (exporte un fn setup(...)) y no puede usar use con otros módulos. Toda sección module debe usarse.

Los módulos estándar están congelados#

La biblioteca estándar viene dentro del compilador y está congelada por versión del lenguaje: std.token en la versión 2 siempre compilará al mismo código. El programa compilado registra el hash BLAKE3 de cada módulo que incluye (tccl abi lo muestra). Las mejoras van a una nueva versión del lenguaje.

std.token — tokens fungibles#

Estado: token_name, token_symbol, token_decimals, total_supply, balances: map[address, int], allowances. Eventos: Transfer(from, to, amount) (emisión: desde la dirección cero; quema: hacia ella), Approval(owner, spender, amount).

Las autorizaciones siguen el patrón habitual y comparten su carrera clásica: para cambiar una autorización de N a M, fíjela primero en 0 y luego en M.

std.items — objetos únicos#

Para coleccionables, objetos de juego, entradas y certificados. Cada objeto tiene un id, un owner, un kind (1–32 bytes), metadata (≤ 1 024 bytes) y la altura created, guardados en el record items.Item. Eventos: ItemCreated(id, owner, kind), ItemTransferred(id, from, to), ItemApproved(id, owner, spender), ItemBurned(id, owner).

Auxiliares: items.create(to, kind, metadata) -> int, items.move_item(id, to), items.burn_item(id). Los metadatos son públicos; guarde un hash o un enlace si el contenido es grande o privado.

std.payments — pagos condicionales#

Retiene TCN hasta que se cumple una condición. Cada pago es un record payments.Payment con un payments.Status que solo puede ir de Pending → Released o Pending → Refunded. Eventos: PaymentCreated(id, payer, payee, amount), PaymentReleased(id, payee, amount, reason), PaymentRefunded(id, payer, amount, reason).

Auxiliares: payments.create(...), payments.pay_out(id, reason), payments.pay_back(id, reason).

Un secreto revelado es público en cuanto la transacción entra en el mempool. Los bloqueos por hash protegen quién cobra, no el secreto en sí. Vea Seguridad.

Vea las recetas con contratos completos y probados que usan cada módulo.

Mejore esta página en GitHub