Ethereum / Solidity dev qui, cercando di migrare alcuni contratti Solidity su Tezos.Speravo di poter far luce su alcune domande

In risposta alla domanda 4:

Riutilizzoe modularità

Si discute di riutilizzoe modularità,di cui l'ereditarietà è uno deitantimeccanismi:

• Michelson non ha alcunmeccanismoperil riutilizzo del codice,adeccezione della chiamata & quot; libreria & quot;esistente contratti direttamente.
• Per quanto ho capito, Archetype nonincludeestendibili dall'utente meccanismiperil riutilizzo del codice. Le azioni (simili aimetodi)nonpossonoessere condivisotra diversemacchine a stati (simile a contratti). Inoltre,le azioninonpossononon chiamarsi a vicenda,quindi nonpuòessere composto. Lemacchine a statinonpossonoessereestese o composto. I contratti degli archetipi sono composti da unfile. Però, Archetype contiene uninsieme diestensioni che siincapsulano comunemente ha utilizzatomodelli come signed,che richiede quell'argomento di un'azione dovrebbeessere lafirma di un altro argomento.
• I contratti LIGO ,indipendentemente dalla sintassi utilizzata,sono composti uninsieme difunzioni. Questefunzionipossonoessere riutilizzatee sonoin formato componibilegenerale come ci si aspetterebbe dafunzioniin qualsiasi lingua,adeccezione della ricorsione. Inoltre,il compilatore Ligo chiamail preprocessore C (cpp) sui contratti diinput,che consente un certogrado di riutilizzoe componibilità attraverso l'uso delle direttive #include. Moralmente,questo èequivalente a copia-incolla delfileincluso:non c'è spazio deinomiper salvarti da conflitti dinome. Infine,l'uso di cppnon è documentatoe soggetto amodifiche,cometestimoniato da questomessaggio da quanto segue messaggio sul canale #ligo sutezos-dev slack :

Attualmente,LIGO vienefornito conilpreprocessore C cpp chefunge dafile sistema dimoduli deipoveri alla C. Ci sono diversimotiviper cui dovremmo sbarazzarsene,siaimmediatamente che a lungotermine [...]

• Infine,i contratti SmartPy ,chein realtà sonoprogrammi Python che utilizzano la libreria SmartPyper costruire un contratto,hanno accesso atutte lefunzionalità di Python a livello dimeta-programmazione (in altreparole,il codice chegenerail contratto). Questo è, moduli,classi (conereditarietà),funzioni,alto livello funzioni,decoratorie composizioni.

Comunicazionetra contratti

• Michelson non hameccanismi specificiper semplificare l'intercontratto comunicazione. Le chiamate ad altri contratti devonoessereeseguitemanualmentetramite Istruzione TRANSFER_TOKENS . I callback devonoessere codificati (dinuovo) manualmente utilizzando lo stile di continuazione delpassaggio (CPS ) .
• Lo stesso valeper LIGO e SmartPy .
• Nella versione corrente, Archetype hapoco supportoper la comunicazionetra contratti. Come per quantoposso vedere,c'è soloil transfer ,con la quale non èpossibile specificare l'argomentonéilpunto diingresso di il contratto chiamato (presumibilmente,lo sono soloi contratti ditipo unit target supportati). Nessun aiutante specificoper la codifica dello stile CPS. Tuttavia,questo vienemodificatonelle versionifuture di Archetype,comeindicato dalla risposta di Benoit di seguito .

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.

Ecco un complemento alla risposta di Arvid riguardo all ' Archetipo :

Riutilizzoe modularità

Le estensioni di Indeed Archetype sono codici riutilizzabiliper aggiungerefunzionalità a un contratto. Adesempio,l'utilizzo dell'estensione "trasferibile " su un ruolo aggiunge al contrattoil azioninecessarie (es.punti diingresso)pertrasferireil ruolo a un altroindirizzo.

Adesempio,invocando l'estensione "trasferibile" su un ruolo di amministratore:

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

genererài duepunti diingresso assign_new_admine confirm_new_admin.

Dalpunto di vista del design,abbiamo cercato dimantenereil contrattoin un unicofile sorgenteilpiùpossibile,perfacilità di letturae per scopi difiducia. Lamaggiorparte dei contratti di Ethereum,adesempio,di solito sono letteralmentefrantumatiin dozzine difile sorgente dameccanismi diereditarietà,e abbiamopensato chefosse l'opposto di come dovrebbe apparire uno smart contract.

Leestensioninon sono ancora disponibilinella versione corrente (0.1.12)ma lo sarannopresto (mancanopochepull request ...).

Comunicazione del contrattotra l'Inter

Esisteil supportoper le chiamate a contrattoin Archetype. Adesempio,il seguente contratto Archetype chiama un contratto all'indirizzo 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)
  }
}
 

Vediamo che lafirma del contratto deveesserefornita con laparola chiave contracte che la chiamata al contratto è simile all'invocazione di unmetodo su un oggetto.

Questafunzione è disponibilenel ramo deve saràpresto disponibilenellaprossima versione (0.1.13in generein unpaio di settimane).

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/Ligofornisconotutto ciò che Michelsonpuòfare attualmente,o ci sono limitazioni conentrambi?

Penso che se qualcosa èpossibilein Michelsone nonin Ligo,probabilmente è unbug che vale lapena segnalare,gli sviluppatori di Ligo di solito rispondono rapidamente a questotipo diproblemi.

Archetype,tuttavia,non èintenzionalmente completo di Turinge inparticolarenon èpossibileeseguire loopillimitatiin Archetype (i loopillimitati sono supportati da LOOPe 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).

Rispetto alla domanda 3,seguendoil commento di @ezy,SmartPy ha alcunefunzionalitàinlining,inclusii nuovi codici operativi,comemostratonelmodello Inline Michelson (dellanuova versione,attualmente https://SmartPy.io/dev ).

È accessibile qui: 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))