Desarrollador de Ethereum / Solidity aquí, buscando migrar algunos contratos de Solidity a Tezos.Esperaba aclarar algunas preguntas

En respuesta a lapregunta 4:

Reutilización ymodularidad

Analizamos la reutilización y lamodularidad,de las cuales la herenciaes uno de losmuchosmecanismos:

• Michelson notiene ningúnmecanismopara reutilizarel código,exceptopara llamar existente & quot;biblioteca & quot; contratos directamente.
• Segúntengoentendido, Arquetipo noincluye Mecanismos de reutilización de código. Las acciones (similares a losmétodos)nopueden compartidoentre diferentesmáquinas deestado (similar a contratos). Además,las accionesnopuedenno llamarseentre sí,por lo que no sepuede componer. Lasmáquinas deestadono sepuedenextender o compuesto. Los contratos de arquetipos se componen de un archivo. Sinembargo, El arquetipo contiene un conjunto deextensiones queencapsulan comúnmente utilizapatrones como signed,que requiere que un argumento de una acción debe ser lafirma de otro argumento.
• Los contratos LIGO ,independientemente de la sintaxis utilizada,se componen de un conjunto defunciones. Estasfunciones sepueden reutilizar yestánen componibleen general como unoesperaría de lasfuncionesen cualquier idioma,conexcepción de la recursividad. Además,el compilador de Ligo llama al preprocesador C (cpp) en los contratos deentrada,que permite un ciertogrado de reutilización y componibilidadmedianteel uso de las directivas #include. Moralmente,estoesequivalente a copiar ypegarel archivoincluido:no hayespacio denombrespara salvarlo de choques denombres. Finalmente,el uso de cppnoestá documentado y sujeto a cambios,como atestiguaestemensajeporel siguiente mensajeen el canal #ligoen tezos-dev slack :

Actualmente,LIGO seenvía conelpreprocesador cpp de C que actúa como el sistema demódulos de lospobres a la C. Hay varias razonespor las que deberíamos deshacerse de él,tanto deinmediato como a largoplazo [...]

• Por último,los contratos SmartPy ,queen realidad sonprogramas de Python que usan labiblioteca SmartPypara construir un contrato,tienen acceso atodas lasfunciones de Pythonen el nivel demetaprogramación (en otraspalabras,el código quegenerael contrato). Es decir, módulos,clases (con herencia),funciones,altonivel funciones,decoradores y composiciones.

Comunicaciónentre contratos

• Michelson notiene mecanismosespecíficospara simplificar laintercontratación comunicación. Las llamadas a otros contratos debenelaborarsemanualmente através del TRANSFER_TOKENS instrucción. Las devoluciones de llamada debenestar codificadas (nuevamente) manualmente usando estilo depaso de continuación (CPS ) .
• Lomismo se aplica a LIGO y SmartPy .
• En la versión actual, Archetype tiene poca compatibilidad con la comunicaciónentre contratos. Como Hasta dondepuedo ver,soloexiste la transfer instrucción,con la que noesposibleespecificarel argumentoni elpunto deentrada de el contrato llamado (presumiblemente,solo los contratos detipo unit son objetivos admitidos). No hay ayudantesespecíficospara codificarelestilo CPS. Sinembargo,esto semodificaen futuras versiones de Archetype,como seindicaen la respuesta de Benoit a continuación .

In response to question 4:

Reuse and modularity

We discuss reuse and modularity, of which inheritance is one of many mechanisms:

• Michelson has no mechanism for code reuse, except for calling existing "library" contracts directly.
• As far as I understand, Archetype includes no user-extendable mechanisms for code reuse. Actions (akin to methods) cannot be shared between different state machines (akin to contracts). Furthermore, actions cannot not call each other, so cannot be composed. State machines cannot be extended or composed. Archetypes contracts are composed of one file. However, Archetype contains a set of extensions, that encapsulate commonly used patterns such as signed, which requires that one argument of an action should be the signature of another argument.
• LIGO contracts, irrespective of the syntax used, are composed of a set of functions. These functions can be reused, and are in general composable as one would expect from functions in any language, with exception of recursion. What's more, the Ligo compiler calls the C preprocessor (cpp) on input contracts, which enables a certain degree of reuse and composability through the use of #include directives. Morally, this is equivalent to copy-pasting the included file: there is no namespacing to save you from name clashes. Finally, the use of cpp is undocumented and subject to change, as testified to by this message by the following message on the #ligo channel on the tezos-dev slack:

Currently, LIGO is shipped with the C preprocessor cpp which acts as a poor man's module system a la C. There several reasons why we should get rid of it, both immediately and in the long term [...]

• Finally, SmartPy contracts, which are actually Python programs that use the SmartPy library to construct a contract, have access to all the Python features on the meta-programming level (in other words, the code that generates the contract). That is, modules, classes (with inheritance), functions, high-level functions, decorators and compositions.

Inter-contract communication

• Michelson has no specific mechanisms to simplify inter-contract communication. Calls to other contracts must be crafted manually through the TRANSFER_TOKENS instruction. Callbacks must be encoded (again) manually using continuation-passing style (CPS).
• The same holds for LIGO and SmartPy.
• In the current version, Archetype has little support for inter-contract communication. As far a I can see, there is only the transfer instruction, with which it is not possible to specify the argument nor the entry-point of the called contract (presumably, only contracts of type unit are supported targets). No specific helpers for coding CPS style. However, this is amended in future versions of Archetype, as indicated by Benoit's answer below.

Aquí hay un complemento a la respuesta de Arvid sobre Arquetipo :

Reutilización ymodularidad

De hecho,las extensiones de Archetype son códigos reutilizablespara agregarfunciones a un contrato. Porejemplo,el uso de laextensión 'transferible 'en un rol agrega al contratoel accionesnecesarias (es decir,puntos deentrada)paratransferirel rol a otra dirección.

Porejemplo,invocar laextensión "transferible"en unafunción de administrador:

 variable admin[%transferable%] role := @tz1iawHeddgggn6P5r5jtq2wDRqcJVksGVSa
 

generará los dospuntos deentrada assign_new_admin y confirm_new_admin.

Desde unaperspectiva de diseño,hemostratado demantenerel contratoen un solo archivofuentetanto como seaposible,parafacilitar la lectura yparagenerar confianza. Lamayoría de los contratos de Ethereum,porejemplo,generalmente se rompenen literalmente docenas de archivosfuentemediantemecanismos de herencia,ypensamos queera lo opuesto a cómo debería verse un contratointeligente.

Lasextensiones aúnnoestán disponiblesen la versión actual (0.1.12)pero loestaránpronto (quedan algunas solicitudes deextracción ...).

Comunicaciónentre contratos

Hay soportepara llamadaspor contratoen Archetype. Porejemplo,el siguiente contrato de arquetipo llama a un contratoen la dirección KT1RNB9PXsnp7KMkiMrWNMRzPjuefSWojBAm

 archetype contract_caller

contract contract_called_sig {
   action set_value (n : int)
   action add_value (a : int, b : int)
}
variable c : contract_called_sig = @KT1RNB9PXsnp7KMkiMrWNMRzPjuefSWojBAm


action update_value(n : int) {
  effect {
    c.set_value(n)
  }
}

action add_one(n : int) {
  effect {
    c.add_value(n, 2)
  }
}
 

Vemos que lafirma del contrato debeproporcionarse con lapalabra clave del contrato y que la llamada al contratoes similar a lainvocación de unmétodoen un objeto.

Estafunciónestá disponibleen la rama de desarrollo yestará disponibleprontoen lapróxima versión (0.1.13normalmenteen unpar de semanas).

Here is a complement to Arvid's answer regarding Archetype:

Reuse and modularity

Indeed Archetype's extensions are reusable codes to add features to a contract. For example, using the 'transferable' extension on a role adds to the contract the necessary actions (ie entry points) to transfer the role to another address.

For example, invoking the 'transferable' extension on an admin role:

variable admin[%transferable%] role := @tz1iawHeddgggn6P5r5jtq2wDRqcJVksGVSa

will generate the two entry points assign_new_admin and confirm_new_admin.

From a design perspective, we have tried to keep the contract in a single source file as much as possible, for ease of reading and trust-carrying purposes. Most of Ethereum's contracts, for example, are usually shattered in literally dozens of source files by inheritance mechanisms, and we thought it was the opposite as what a smart contract should look like.

Extensions are not available yet in the current version (0.1.12) but will be soon (they are a few pull requests away ...).

Inter contract communication

There is support for contract calling in Archetype. For example, the following Archetype contract calls a contract at address KT1RNB9PXsnp7KMkiMrWNMRzPjuefSWojBAm

archetype contract_caller

contract contract_called_sig {
   action set_value (n : int)
   action add_value (a : int, b : int)
}
variable c : contract_called_sig = @KT1RNB9PXsnp7KMkiMrWNMRzPjuefSWojBAm


action update_value(n : int) {
  effect {
    c.set_value(n)
  }
}

action add_one(n : int) {
  effect {
    c.add_value(n, 2)
  }
}

We see that the contract signature must be provided with the contract keyword and that the call to the contract is similar to invoking a method on an object.

This feature is available in the dev branch and will be available soon in the next release (0.1.13 typically in a couple of weeks).

¿Archetype/Ligoproporcionatodo lo que Michelsonpuede hacer actualmente,oexisten limitacionesen ambos?

Creo que si algoesposibleen Michelson ynoen Ligo,probablemente sea unerror que valga lapenainformar,los desarrolladores de Ligo suelen responder rápidamente aestetipo deproblemas.

Sinembargo,el arquetiponoes Turing completo apropósito y,en particular,nopuede hacerbuclesilimitadosen Archetype (losbuclesilimitados son compatibles con LOOP y LOOP_LEFT).

Do Archetype/Ligo provide everything that Michelson can currently do, or are there limitations with either?

I think if something is possible in Michelson and not in Ligo, it is probably a bug worth reporting, the Ligo devs usually quickly answer these kinds of issues.

Archetype however is purposely not Turing complete and in particular you cannot do unbounded loops in Archetype (unbounded loops are supported by the LOOP and LOOP_LEFT).

Con respecto a lapregunta 3,siguiendoel comentario de @ezy,SmartPytiene algunas capacidades deinserción,incluso connuevos códigos de operación como semuestraen laplantilla Inline Michelson (de lanueva versión,actualmente https://SmartPy.io/dev ).

Sepuede acceder aquí: https://smartpy.io/dev/index.html?template=inlineMichelson.py .

 import smartpy_michelson as mi

...

    @sp.entry_point
    def concat(self, params):
        concat = mi.operator("CONCAT", [sp.TList(sp.TString)], [sp.TString])
        self.data.s = concat(["a", "b", "c"])

    @sp.entry_point
    def seq(self, params):
        self.data.value = abs(mi.seq([mi.ADD(), mi.MUL(), mi.DUP(), mi.MUL()], 15, 16, 17))
 

With respect to question 3, following @ezy remark, SmartPy has some inlining capabilities including with new opcodes as shown in the Inline Michelson template (of the new version, currently https://SmartPy.io/dev).

It's accessible here: https://smartpy.io/dev/index.html?template=inlineMichelson.py.

import smartpy_michelson as mi

...

    @sp.entry_point
    def concat(self, params):
        concat = mi.operator("CONCAT", [sp.TList(sp.TString)], [sp.TString])
        self.data.s = concat(["a", "b", "c"])

    @sp.entry_point
    def seq(self, params):
        self.data.value = abs(mi.seq([mi.ADD(), mi.MUL(), mi.DUP(), mi.MUL()], 15, 16, 17))