Ethereum / Solidity Dev ici, cherchant à migrer certains contrats de solidité sur Tezos.J'espérais avoir un hangar de lumière sur quelques questions

En réponse à la question 4:

Réutilisationet modularité

Nous discutons de la réutilisationet de lamodularité,dont l'héritageest l'un desnombreuxmécanismes:

• Michelson n'a aucunmécanismepour la réutilisation du code,à l'exception de l'appel existant "bibliothèque" contrats directement.
• autant queje comprendsbien, archétype n'inclut aucun utilisateurextensible de l'utilisateur Mécanismespour la réutilisation du code. Les actions (semblable auxméthodes)ne peuventpas être partagéentre différentesmachines d'état (semblable à contrats). En outre,les actionsne peuventpas s'appeler,alors nepeutpas être composé. Lesmachines d'étatne peuventpas être étendues ou composé. Les contrats d'archétypes sont composés d'unfichier. Pourtant, L'archétype contient unensemble d'extensions quiencapsulent couramment modèles utiliséstels que signé ,ce quinécessite un argument de Une action devrait être la signature d'un autre argument.
• ligo contrats,quelle que soit la syntaxe utilisée,sont composées de unensemble defonctions. Cesfonctionspeuvent être réutiliséeset sont dans généralement composable comme onpourrait s'attendre à desfonctions danstout langue,avecexception de la récursion. Deplus,le compilateur de Ligo appelle le C Préprocesseur ( CPP ) sur les contrats d'entrée,qui Permet à un certain degré de réutilisationet de composition à l'aide de l'utilisation de #include directives. Moralement,cela équivaut à Copier-coller lefichierfourni:iln'y apas denoms denomspour vous sauver des affrontements denom. Enfin,l'utilisation de CPP est sanspapierset Sous réserve demodification,commetémoignage de cemessagepar ce qui suit Message sur le #Ligo Channel sur le Slack Tezos-Dev Slack :

Actuellement,Ligoestexpédié avec le CPP dupréprocesseur C activeen tant que le système demodule depauvre homme a la C. Il y aplusieurs raisonspour lesquellesnous devrions se débarrasser de celui-ci,à lafoisimmédiatementet à longterme [...]

• Enfin, Smartpy SmartPy Les contrats,qui sonten réalité desprogrammes Python qui utilisent labibliothèque SmartPypour construire un contrat,avoir accès àtoutes les caractéristiques Python sur leniveau méta-programmation (dans Autresmots,le code quigénère le contrat). C'est-à-dire, Modules,classes (avec héritage),fonctions,hautniveau Fonctions,décorateurset compositions.

• michelson n'apas demécanismes spécifiquespour simplifier lesintercédents la communication. Les appels à d'autres contrats doivent êtrefabriquésmanuellement àtravers le transfert_tokens instruction. Les rappels doivent être codés (ànouveau) manuellementen utilisant Style depassage de continuation (CPS ) .
• Lesmêmes contestepour ligo et SmartPy SmartPy .
• dans la version actuelle, archétype apeu de soutienpour la communicationinter-contrat. Comme loin A,je peux voir,iln'y a que le Transfert instruction,avec lequel Iln'estpaspossible de spécifier l'argumentni lepoint d'entrée de Le contrat appelé (probablement,seuls les contrats detype unité sont ciblesprisen charge). Aucun aide spécifiquepour coder style CPS. Toutefois,celaestmodifié dans lesfutures versions de l'archétype,commeindiquépar La réponse de Benoit ci-dessous .

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.

Voici un complément à la réponse d'Arvid concernant archétype :

réutilisationet modularité

effectif de l'archétype's Extensions sont des codes réutilisablespour ajouter desfonctionnalités à un contrat. Parexemple,à l'aide de " Transférable 'extension sur un rôle ajoute au contrat le contrat le actionsnécessaires (c.-à-d.points d'entrée)pourtransférer le rôle à une autre adresse.

Parexemple,invoquant l'extension "transférable" sur un rôle administrateur:

  Admin variable [%transférable %%] Rôle:=@ TZ1IAWEDDGGGN6P5R5JTQ2WDRQCJVKSGVSA
 

générera les deuxpoints d'entrée assign_new_admin et confirm_new_admin .

Dans uneperspective de conception,nous avonsessayé de conserver le contrat dans un seulfichier source autant quepossible,pour unefacilité de lectureet desfins detransport de confiance. Laplupart des contrats d'Etherurum,parexemple,sontgénéralementbrisés dans la littéralement des dizaines defichiers sourcepar desmécanismes d'héritageet nous avonspensé que c'était l'inverse comme ce qu'un contratintelligent devrait ressembler.

Lesextensionsne sontpasencore disponibles dans la version actuelle (0.1.12)mais serontbientôt (elles sont quelques demandes detirage ...).

communicationentre contrat

Il y a un soutien à l'appel du contrat dans l'archétype. Parexemple,le contrat d'archétype suivant appelle un contrat à l'adresse KT1RNB9PXSNP7KMKIMRWNMRZPJUEFSWOJBAM

  archétype contract_caller

Contract contractuel_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) {
  Effet {
    c.set_value (n)
  }
}

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

Nous voyons que la signature du contrat doit êtrefournie avec lemot-clé Contratet que l'appel au contratest similaire àinvoquer uneméthode sur un objet.

Cettefonctionnalitéest disponible dans labranche de développementet sera disponiblebientôt dans laprochaine version (0,1.13typiquement dans quelques semaines).

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).

L'archétype/ligofournittout ce que Michelsonpeut actuellementfaire ouexiste-t-il des limitations avec soit?

Jepense que si quelque choseestpossible à Michelsonet non à Ligo,c'estprobablement unbug quimérite d'être signalé,le Ligo Devs répondgénéralement rapidement à cestypes deproblèmes.

L'archétypeesttoutefois délibérémentnontué completet enparticulier,vousne pouvezpasfaire deboucles sansbornes dans l'archétype (lesboucles sansbornes sontprisesen chargepar laboucleet laboucle).

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).

En ce qui concerne la question 3,après @ezy Remarque,SmartPy a des capacités d'inlinage,y compris avec denouveaux opcodes,commeindiqué dans lemodèle Inline Michelson (de lanouvelle version,actuellement https://smartpy.io/dev ).

Ilest accessibleici: https://smartpy.io/dev/index.html? Modèle=inllinemichelson.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))