Como parte del lanzamiento de Algorand Versión 2.0, la red ahora admite Algorand Smart Contracts (ASC1), que son contratos inteligentes de capa 1. Estos contratos no solo funcionan como parte del protocolo, sino que también pueden interactuar con todas las características adicionales de la capa 1 en la versión 2.0. Esto incluye transferencias atómicas y activos estándar de Algorand (ASA).
Brian Olson explica Algorand Smart Contracts
Los Contratos Inteligentes de Algorand son pequeños programas escritos en un lenguaje similar al ensamblado que se pueden usar como reemplazo de firmas dentro de una transacción. Este lenguaje se llama Langauge de aprobación de ejecución de transacción o TEAL. Más información sobre la especificación del lenguaje TEAL en un momento.
Los programas TEAL tienen una función principal y es devolver verdadero o falso y se utilizan para analizar y aprobar transacciones. Las transacciones estándar se firman con una clave privada o un conjunto de claves privadas multigrado. Con la introducción de ASC1, ahora se pueden firmar con un programa TEAL. Esto se llama una firma lógica.
El código TEAL tiene dos escenarios de uso básicos; como una cuenta de contrato o como una firma delegada.
Cuando se utiliza como una cuenta de contrato, se compila el código TEAL, que devuelve una dirección de Algorand. La dirección de la cuenta del contrato se puede enviar Algos o Algorand Assets desde cualquier cuenta utilizando una transacción estándar. Cuando se envía desde una cuenta de contrato, la lógica en el programa TEAL determina si se aprueba la transacción. Las cuentas de contrato son excelentes para configurar cuentas de depósito en garantía donde se dice que desea limitar los retiros o desea realizar pagos periódicos, etc.
También puede usar TEAL para hacer firmas delegadas, lo que esencialmente significa que firma un programa TEAL con su clave privada o claves multigrado y puede guardar esta firma lógica para que alguien más envíe sus transacciones con su autoridad. El programa TEAL puede limitar la cantidad de autoridad que delega. Por ejemplo, puede crear una firma delegada que permita a una empresa de servicios públicos eliminar hasta x Algos cada 50000 bloques de su cuenta.
Los programas TEAL se pueden escribir con cualquier editor, pero actualmente solo se pueden compilar utilizando la herramienta de línea de comandos de objetivos. La herramienta de línea de comandos proporciona la capacidad de usar estos programas compilados dentro de las transacciones. Además, la herramienta de línea de comandos también proporciona la capacidad de probar el programa antes de usarlo con una transacción real. El programa más simple que puede escribir en TEAL es probablemente el siguiente:
// simple.teal
// No uses esto en una aplicación real
int 1
Si bien es muy simple, este programa nunca debe usarse en producción, ya que siempre devolverá una verdadera autenticación cuando se use. Lo usamos aquí con fines ilustrativos de cómo llamar a los programas TEAL.
Compilaría este programa con objetivo utilizando el siguiente comando:
empleado de la meta compilar simple.teal
Esto produciría el siguiente resultado:
$ goal clerk compile simple.teal
simple.teal: 6Z3C3LDVWGMX23BMSYMANACQOSINPFIRF77H7N3AWJZYV6OH6GWTJKVMXY
Tenga en cuenta que tenemos una dirección. Esta es la dirección que desea usar si planea usar esto como una cuenta de contrato. En este caso, queremos usarlo para crear una firma delegada, por lo que debemos firmar el programa verde azulado con nuestra clave privada. El siguiente ejemplo muestra el uso del objetivo para compilar e iniciar sesión en una operación.
Compilador de objetivos de compilación simple.teal -o mydelegatedsig.lsig -s -a C3MKH24QL3GHSD5CDQ47ZNQZMNZRX4MUTV6LVPAXMWAXMIISYSOWPGH674 -d ~ / node / data
En este caso, estamos firmando la lógica con la dirección especificada con el parámetro -a. Tenga en cuenta que si no tiene una billetera predeterminada asignada, también deberá especificar la billetera con el parámetro -w.
Ahora tenemos el archivo mydelegatedsig.lsig que contiene una firma lógica que cualquier persona que tenga este archivo puede usar en una transacción. Debido a que la lógica siempre vuelve a ser verdadera, ¡esto esencialmente le da a cualquiera acceso completo a su cuenta!
La firma lógica creada podría usarse en una transacción como:
encargado de envío de objetivos -f C3MKH24QL3GHSD5CDQ47ZNQZMNZRX4MUTV6LVPAXMWAXMIISYSOWPGH674 -a 1000000 -t STF6TH6PKINM4CDIQHNSC7QEA4DM5OJKKSACAPWGTG776NW-Qe-gd
Tenga en cuenta que en este caso, -f es la cuenta que firmó la firma lógica y la opción -t es el receptor de la transacción. Además, tenga en cuenta que la tarifa de transacción la paga la cuenta que firmó la firma lógica.
También puede usar la opción -o en el ejemplo anterior para escribir la transacción firmada en el archivo y no se enviará a la red. Puede usar la salida con el comando dryrun para ver cómo se procesa realmente el TEAL.
.in.
tx (0) costo = 2 rastreo:
1 intcblock =>
4 intc_0 => 1 0x1- pasar –
Para obtener más ejemplos de uso de objetivo con TEAL, consulte el Tutorial ASC1. Este tutorial lo guía a través de muchos de los comandos de objetivos y lo que puede hacer con un programa TEAL. Consulte la sección de Especificación del idioma TEAL de esta publicación para obtener más detalles sobre cómo escribir un programa TEAL. El SDK de Algorand también proporciona métodos para llamar a los programas TEAL. Ese tema se trata en la siguiente sección.
Los archivos binarios creados al compilar un programa TEAL se pueden cargar y usar en cualquiera de los SDK de Algorand, que son compatibles con Java, JavaScript, Go y Python. La página de uso del SDK de ASC1 cubre cada idioma en detalle. Con fines ilustrativos, podemos mostrar el uso del programa simple.teal anterior para llamar a una transacción con la firma delegada. Este programa replica los comandos de la sección anterior y se implementa para ejecutarse con Node.js.
const algosdk = require ('algosdk');
const fs = require ('fs'); // Recuperar el token, el servidor y el puerto
// valores para su instalación en algod.net
// y archivos algod.token dentro del directorio de datos
const token = "yournodetoken";
const server = "http://127.0.0.1";
const port = 8080; // Recuperar la cuenta
// C3MKH …
var mnemónico = "práctica de ascenso despierto diez calma mutua" +
"Expande el peligro doce inhala cerca de la cosecha asegura" +
"el corazón de la vida está bien pasa el objetivo libre prioritario" +
"rebaño mal esencia poeta ausente";
var recoveryAccount = algosdk.mnemonicToSecretKey (mnemonic);
console.log (recoveryAccount.addr); // instanciar el contenedor algod
let algodclient = new algosdk.Algod (token, servidor, puerto);
(async () => {
// Obtenga los parámetros relevantes de algod
// para los parámetros sugeridos
let params = await algodclient.getTransactionParams ();
let endRound = params.lastRound + parseInt (1000);
dejar tarifa = esperar algodclient.suggestedFee (); // Estos son el volcado base64 del
// compila el programa simple.teal
// Línea de comando usada $ cat simple.teal.tok | base64
let program = new Uint8Array (Buffer.from ("ASABASI =", "base64"));
// el método makeLogicSig toma el programa y los parámetros
// en este ejemplo no tenemos parámetros
let lsig = algosdk.makeLogicSig (programa);
// firma la lógica con el secreto de tus cuentas
// llave. Esto esencialmente le está dando a su
// autoridad clave para cualquiera con el lsig
// y si la lógica devuelve verdadero
// tenga mucho cuidado
// Si esto fuera un uso de cuenta contractual
// no harías esta operación de signo
lsig.sign (recoveryAccount.sk); // En este punto, puede guardar el lsig y compartir
// como su firma delegada.
// La clase LogicSig admite la serialización y
// proporciona los métodos lsig.toByte y fromByte
// para convertir fácilmente para guardar archivos y
// reconstituir y LogicSig objeto // Crear una transacción
dejar txn = {
"from": recoveryAccount.addr,
"a": "STF6TH6PKINM4CDIQHNSC7QEA4DM5OJKKSACAPWGTG776NWSQOMAYVGOQE",
"tarifa": params.fee,
"cantidad": 200000,
"firstRound": params.lastRound,
"lastRound": endRound,
"genesisID": params.genesisID,
"genesisHash": params.genesishashb64
}; // Crear transacción lógica firmada.
// Si se tratara de una cuenta contractual, lsig no contendría el
// firma pero se enviaría de la misma manera
let rawSignedTxn = algosdk.signLogicSigTransaction (txn, lsig); // Guarde el archivo de transacción firmado para fines de depuración
// Usar con el secretario de objetivos dryrun -t simple.stxn para
// ver cómo se procesa la lógica
// Comenta si no planeas usar dryrun
fs.writeFileSync ("simple.stxn", rawSignedTxn.blob); // Enviar la transacción firmada lsig
let tx = (espera algodclient.sendRawTransaction (rawSignedTxn.blob));
console.log ("Transacción:" + tx.txId);}) (). catch (e => {
console.log (e);
});
Brian Olson cubre TEAL ampliamente en el video adjunto anteriormente en esta publicación.
Como se indicó anteriormente, TEAL es un lenguaje similar a un ensamblado y se procesa con una máquina de pila.
El lenguaje es un lenguaje no completo que no admite bucles pero admite ramificaciones hacia adelante. Los programas TEAL se procesan una línea a la vez que empujan y extraen valores de la pila. Estos valores de pila son enteros de 64 bits sin signo o cadenas de bytes. TEAL proporciona un conjunto de operadores que operan en los valores dentro de la pila. TEAL también permite que los argumentos pasen al programa desde una transacción, un espacio temporal para almacenar valores temporalmente para su uso posterior en el programa, acceso a propiedades de transacciones agrupadas o únicas, valores globales, un par de pseudooperadores, constantes y algún control de flujo funciona como bnz para ramificar.
Descripción general de la arquitectura TEAL
Obtener propiedades de transacción
El propósito principal de un programa TEAL es devolver verdadero o falso. Cuando el programa se completa si hay un valor distinto de cero en la pila, devolverá verdadero y si tiene un valor cero o la pila está vacía, devolverá falso. Si la pila tiene más de un valor actualmente, el programa también devolverá falso. Mirando el diagrama anterior, los primeros dos comandos se procesarían como:
Línea de programa número 1:
Recuperando propiedades de transacción
Tenga en cuenta que estamos usando txnto referenciar las listas de propiedades de transacciones actuales. Si estuviéramos usando este programa con una transacción agrupada, haríamos referencia al grupo de transacciones usando gtxn. Usaría el Tamaño de grupo global para obtener el número de transacciones en el grupo. Luego puede usar gtxn 0 Receive para obtener el receptor de la primera transacción.
Pseudo códigos de operación
Continuando con el ejemplo anterior.
Línea de programa número 2:
Pseudo códigos de operación
Aquí estamos usando el pseudo código de operación addr para convertir una dirección codificada en una constante de byte para colocar en la pila. Consulte la documentación de TEAL Overview para obtener pseudo códigos de operación adicionales.
Operaciones
TEAL proporciona muchos operadores para trabajar con datos que están en la pila. Consulte la documentación de TEAL Overview para obtener una lista completa de operadores. La mayoría de los operadores actúan sobre los dos últimos valores en la pila. Algunos operadores actúan sobre uno o más de dos valores de la pila. La documentación de los códigos de operación TEAL explica el número de argumentos y si algo se devuelve a la pila como resultado de la operación.
Línea de programa número 3:
Operadores
Paso de argumento
Más adelante en el código tenemos una llamada para cargar el primer argumento en la pila.
Línea de programa número 13:
Parámetros
Todos los parámetros de argumento para un programa TEAL son conjuntos de bytes. El orden en que los pasa también es específico. En este caso, estamos cargando el primer parámetro en la pila. La mayoría de los SDK proporcionan funciones de lenguaje estándar que le permiten convertir parámetros a una matriz de bytes. Si está utilizando la línea de comando del objetivo, los parámetros deben pasarse como cadenas codificadas en base64. Por lo tanto, deberá convertir sus parámetros antes de pasarlos. Por ejemplo, si desea pasar “argumento de mystring”, puede usar un comando de Python como el siguiente para convertirlo en una cadena base64 para el objetivo.
$ echo -n mystringargument | base64
Lo que devolverá el siguiente resultado.
bXlzdHJpbmdhcmd1bWVudA ==
Este resultado se puede usar junto con el parámetro – b64args para el comando de envío del empleado de objetivos.
el secretario de objetivos envía -a 1000 -c fromaddr –to toaddr –from-program myteal.teal –argb64 "bXlzdHJpbmdhcmd1bWVudA ==" -d ~ / node / data
Si está intentando pasar un valor entero de 123, puede usar un comando python como el siguiente para obtener la cadena codificada en base64. Tenga en cuenta que actualmente, TEAL no admite números negativos.
$ python3 -c "import base64; print (base64.b64encode ((123) .to_bytes (8, 'big')))"
Lo que dará como resultado lo siguiente.
'AAAAAAAAAHs ='
En los SDK puede usar las funciones del idioma nativo. Por ejemplo, para pasar un argumento de cadena al SDK de Python, usaría un código similar al siguiente ejemplo.
arg_str = "mi cadena"
arg1 = arg_str.encode ()
lsig = transacción.LogicSig (programa, args = (arg1))
Para el argumento Integer que usaría (recuerde que TEAL solo admite valores positivos):
arg1 = (123) .to_bytes (8, 'grande')
lsig = transacción.LogicSig (programa, args = (arg1))
Almacenamiento y carga desde Scratchspace
TEAL proporciona un espacio reutilizable como una forma de almacenar temporalmente los valores para su uso posterior en su código. En el siguiente ejemplo, primero cargamos 12 en la pila y luego lo duplicamos. A continuación, multiplicamos esos dos números, lo que resulta en 144 en la parte superior de la pila. El comando store se usa para almacenar este valor en el espacio de scratch space 1.
Almacenar un valor en Scratch Space
Más tarde podemos recuperar este valor utilizando el comando de carga. Tenga en cuenta que esta operación no despeja la ranura de espacio de trabajo. El valor se puede volver a cargar, más adelante en el programa.
Recuperar un valor de Scratch Space
Usando el parámetro de arrendamiento
Otra cosa a tener en cuenta es la existencia del nuevo parámetro de arrendamiento de transacciones. Este parámetro es muy útil para evitar que alguien envíe dos veces una transacción. Este parámetro es un 32 bytes cadena que crea (el objetivo espera que esté codificado en base64) que, combinado con el campo del remitente, hace que la transacción sea única. Si alguien vuelve a enviar la transacción del mismo remitente y el mismo parámetro de arrendamiento, será rechazado, hasta la última ronda válida para la transacción. Una vez que pase la última ronda válida el contrato de arrendamiento anterior caduca y una nueva transacción con el mismo remitente y contrato de arrendamiento Se puede enviar de nuevo. Puede acceder al parámetro de arrendamiento en TEAL utilizando la llamada de arrendamiento txn.
Costo operativo de los códigos de operación TEAL
Los programas TEAL están limitados a 1000 bytes de tamaño. Este es el tamaño del programa compilado más los argumentos. Además, para mantener la velocidad, también están limitados por el costo del código de operación. Este límite se establece en 20000 para todo el programa, donde la mayoría de los códigos de operación cuestan 1 y algunos cuestan más. Por ejemplo, para usar la función SHA256 que obtiene el valor SHA256 del último valor en la pila cuesta 7. Algunos códigos de operación son muy caros, como el uso de la función de verificación ed25519 que cuesta 1900. La página de códigos de operación TEAL enumera el costo de todos los códigos de operación.
La especificación del lenguaje TEAL se describe completamente en la página de referencia del lenguaje de aprobación de ejecución de transacciones y la lista completa de códigos de operación admitidos por TEAL se describe en la página de referencia de códigos de operación TEAL.
Para ver un ejemplo documentado línea por línea de un programa TEAL, consulte el Ejemplo de depósito de garantía ASC1 que cubre cómo se procesa la pila.
Lo que un programa verde azulado no puede hacer
TEAL, aunque muy potente, está limitado por el diseño en varias áreas. La razón de esto es continuar garantizando un rendimiento rápido en la red Algorand. Si bien TEAL puede analizar una transacción o grupo de transacciones, no puede cambiar una transacción. TEAL no puede buscar saldos de Algo o Algorand Standard Asset. TEAL no puede buscar información en bloques o transacciones anteriores. TEAL no sabe en qué ronda la transacción actual realmente se comprometerá con el libro mayor, aunque conocerá el rango de ronda. TEAL tampoco sabrá el momento en que se confirma una transacción. Además, como se indicó anteriormente, TEAL no puede reaparecer y solo puede avanzar.
Pautas
Debido a que TEAL es muy poderoso, requiere que los desarrolladores tengan mucho cuidado de probar ciertas restricciones, como asegurarse de probar que la tarifa de transacción no es astronómica o verificar que todos los parámetros requeridos estén establecidos. Para ver una lista de pautas, así como consejos y patrones comunes, consulte la página de Descripción general de TEAL.
TEAL es un lenguaje poderoso ya que reemplaza la autoridad de firma en las transacciones. Para ayudar a los desarrolladores a comenzar y proporcionar una funcionalidad común sobre el uso de TEAL, Algorand está desarrollando un conjunto de plantillas de TEAL que se pueden configurar mediante un enfoque de plantilla. Estas plantillas también estarán disponibles con los SDK individuales. A partir de la versión 2.0 de Algorand, actualmente tenemos 2 plantillas principales. Estas son la plantilla de contrato de bloqueo de tiempo de hash y el contrato dividido. A medida que desarrollemos más, se agregarán a esta lista en el sitio del desarrollador. Si desea seguir el desarrollo o ayudar con el proyecto, eche un vistazo a la ubicación de la plantilla dentro del Repositorio Algorand Github. Este directorio contiene el código principal para las plantillas y el directorio de documentos contiene una descripción línea por línea del código TEAL y el uso de estos contratos inteligentes.
Como parte de la documentación de cada contrato inteligente, proporcionamos una descripción general del ASC y una página del SDK sobre cómo crear instancias y usar la plantilla dentro del código. Por ejemplo, puede revisar la descripción general de la plantilla HTLC aquí y ver cómo se usa dentro de cada uno de los SDK aquí.
Esta lista continuará creciendo con el tiempo, así que asegúrese de revisarla con frecuencia.
