Ethereum / solidez dev aqui, olhando para migrar alguns contratos de solidez para Tezos.Esperava ter alguma coisa leve em algumas perguntas

Em resposta àpergunta 4:

Reutilizaçãoe modularidade

Discutimos reutilizaçãoe modularidade,dos quais a herança é um dosmuitosmecanismos:

• michelson nãotem mecanismopara reutilização de código,excetopara chamar Existente & quot;biblioteca? contratos diretamente.
• Tanto quantoeuentendo, arquétipo incluinenhum usuárioextensível mecanismospara reutilização de código. Ações (semelhantes amétodos)nãopodem ser compartilhadoentre diferentesmáquinas deestado (semelhante a contratos). Além disso,as açõesnãopodem ligar umas às outras,então nãopode ser composto. Máquinasestaduaisnãopodem serestendidas ou composto. Os contratos de arquétipos são compostos de um arquivo. Contudo, Arquétipo contém um conjunto deextensões,queencapsulam padrões usados,como signed,que requer que um argumento de Uma ação deve ser a assinatura de outro argumento.
• ligo contratos,independentemente da sintaxe utilizada,são compostos de um conjunto defunções. Essasfunçõespodem ser reutilizadase estãoem geral composto como seesperaria defunçõesem qualquer linguagem,comexceção da recursão. Além disso,o compilador Ligo Chama o cpré-processador (cpp) em contratos deentrada,que Permite um certograu de reutilizaçãoe composia através do uso de #include diretivas. Moralmente,isso éequivalente a Copiar-colando o arquivoincluído:não hánamespacingpara salvar você de confrontos denome. Finalmente,o uso de cpp éindocumentadoe Sujeito a alterações,comotestemunhadoporestamensagempelo seguinte Mensagemno canal #ligonafolga Tezos-Dev :

.

Atualmente,o Ligo éenviado com o CPP dopré-processador C que atua como um Sistema demódulo dopobre homem A LA C. Há várias razõespelas quais deveríamos Livre-se dele,tantoimediatamente quanto a longoprazo [...]

• finalmente, smartpy contratos,que são,na verdade,programas Python que usam abiblioteca Smartpypara construir um contrato,ter acesso atodos os recursos do Pythonnonível deprogramação demetadologia (em Outraspalavras,o código quegera o contrato). Aquilo é, módulos,classes (com herança),funções,altonível Funções,decoradorese composições.

Comunicaçãoentre contratação

• michelson nãotem mecanismosespecíficospara simplificarentre contrato comunicação. As chamadaspara outros contratos devem sertrabalhadasmanualmente através do TRANSFER_TOKENS instrução. Callbacks devem ser codificados (novamente) Manualmente usando Estilo depassagem de continuação (CPS )
• osmesmosmantidospara ligo e smartpy .
• Na versão atual, arquétipo tem pouco suportepara comunicaçãoentre contratos. Como Diante de queeuposso ver,há apenas o transfer instrução,com o qual Não épossívelespecificar o argumentonem oponto deentrada de o contrato chamado (presumivelmente,apenas contratos detipo unit são alvos suportados). Nenhum ajudanteespecíficopara codificar oestilo CPS. Noentanto,isso é alteradoem versõesfuturas do arquétipo,conformeindicadopor A resposta de Benoit abaixo .

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.

Aquiestá um complemento à resposta da Arvid sobre arquétipo :

reutilizaçãoe modularidade

Realmente Archetype's Extensões são códigos reutilizáveis ​​para adicionar recursos a um contrato. Porexemplo,usando o 'transferível 'extensãoem umafunção adiciona ao contrato açõesnecessárias (ou seja,pontos deentrada)paratransferir afunçãopara outroendereço.

Porexemplo,invocando aextensão 'transferível'em umafunção administrativa:

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

irágerar os doispontos deentrada assign_new_admine confirm_new_admin.

De umaperspectiva de design,tentamosmanter o contratoem um único arquivo de origem,tanto quantopossível,parafacilitar a leiturae osfins detransporte de confiança. Amaioria dos contratos de Ethereum,porexemplo,sãogeralmente quebradosem literalmente dezenas de arquivos de origempormecanismos de herança,e pensamos queera o oposto como o que um contratointeligente deveria ser.

Extensões aindanãoestão disponíveisna versão atual (0.1.12),mas serãoem breve (eles são algumas solicitações depuxarembora ...).

comunicaçãoentre contratos

Há suportepara o contrato chamandono arquétipo. Porexemplo,o seguinte contrato de arquétipo chama um contratonoendereço 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 a assinatura do contrato deve serfornecida com apalavra-chave contratoe que a chamadapara o contrato é semelhante àinvocação de ummétodoem um objeto.

Este recursoestá disponívelno ramo Deve estará disponívelem brevenapróxima versão (0,1.13tipicamenteem algumas 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).

.

O arquétipo/Ligofornecetudo o que Michelsonpode atualmente,ou há limitações com?

Eu acho que se algo épossívelem Michelsone nãoem Ligo,éprovavelmente umbug que vale apena reportar,os devs lívolosgeralmente respondem rapidamente aessestipos deproblemas.

O arquétipo,noentanto,nãoestáintencionalmente,não é concluídoe,em particular,vocênãopodefazer loopsilimitadosno Archetype (loopsilimitados são suportadospelo 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).

Com relação àpergunta 3,após Observação @ezy,Smartpytem algumas capacidadesinglesas,incluindo comnovos opcodes,conformemostradonomodelo Inline Michelson (danova versão,atualmente https://smartpy.io/dev ).

É acessível aqui: https://smartpy.Io/Dev/Index.html?modelo=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))