Consommation de gaz dans une chaîne de transferts internes

Vousne pouvezpas dépasser le HARD_GAS_LIMIT_PER_OPERATION=400000. Cela seraprobablement augmenté dans lesfutursprotocoles,cependant (voirparexemple le " Athènes "Propositions ).

Lestransfertsinternespeuvent utiliserbeaucoup degaz.

Premièrement,ilexiste un coûtfixe de 10000gazpartransfert.

seconde,et plusimportantencore,lorsqu'un contratest «analysé»,l'ensemble du code et sont lus hors de labase de données Tezos (à l'exception du BIG_MAP ). Vouspayez dugaz selon lataillebinaire des données. L'ensemble du code est également "analysé",afin detirer letype deparamètre du contratet de le comparer autype attendu. Cela seproduit dans aumoins deuxplaces:

1. Lorsque vous avez contrat P dans votre stockage (en dehors du big_map ),le contrat sera analysé avant que votre scriptne fonctionne.
2. Lorsque votre scriptexécute l'instruction contrat Michelson,le contrat sera analysé.

Donc,cela signifie quepourtransférer_tokens vers un contrat scripté,vous devez l'analyser,payer desgazproportionnels à sataille de codeet de stockage. Lorsque ce contrat reçoit letransfertet est chargépour êtreexécuté,ce coût,et plus,serapayé ànouveau ,avant que le script de destinationne commencemême à courir.

(c'est complètement inutilepour le stockage à lire dans labase de données lors de l'analyse d'un contrat. Nouspourrions résoudre ceproblème demanièretriviale dans unefuturemise àniveau duprotocole -et nous Cela devrait vraiment,celapeut conduire à des vulnérabilitéstrès surprenantes. Il seramoinsfacile de résoudre leproblème avec code ,maisje m'attends à ce qu'il soit corrigé unjour,en divisant le code dansplusieurspièces de labase de données. Peut-être que celapeut arriver lorsquenous ajoutons despoints d'entrée depremière classe.)

Donc,unefaçon d'atténuer celaest de vous assurer que chaque contratimpliqué a unpetit codeet un stockage - saufpour le Big_MAP. Vousne payez que dugazpour le contenu du Big_Map lorsque vous obtenez (etpeut-être Déballez ).

Malheureusement,cela semble signifier que,aujourd'hui,lamanière laplus optimale d'écrire des contrats complexes (enparticulier lorsqu'elles sont la destination destransfertsinternes) seront d'utiliser big_map octets octets comme stockage,et Pourmettretout le codeet le stockage à l'intérieur du Big_MAP,le chargement de la demande,à l'aide de déballage.

You cannot exceed the hard_gas_limit_per_operation = 400000. It will probably be increased in future protocols, though (see e.g. the "Athens" proposals).

Internal transfers can use up a lot of gas.

First, there is a fixed cost of 10000 gas per transfer.

Second, and more importantly, when a contract is 'parsed', the contract's entire code and storage are read out of the Tezos database (except for the big_map). You pay gas according the binary size of the data read. The entire code is also 'parsed', in order to pull out the parameter type of the contract, and compare it to the expected type. This happens in at least two places:

1. When you have contract p in your storage type (outside of the big_map), the contract will be parsed before your script runs.
2. When your script executes the CONTRACT p Michelson instruction, the contract will be parsed.

So, this means that in order to TRANSFER_TOKENS to a scripted contract, you must parse it, paying gas proportional to its code and storage size. When that contract receives the transfer and is loaded to be executed, this cost, and more, will be paid again, before the destination script even starts running.

(It is completely unnecessary for the storage to be read from the database when parsing a contract. We could fix this trivially in a future protocol upgrade -- and we really should, it can lead to very surprising vulnerabilities. It will be less easy to fix the problem with code, but I expect it will be fixed someday, by splitting the code into several pieces in the database. Maybe this can happen when we add first-class entry points.)

So, one way to mitigate this is to make sure that every contract involved has small code and storage -- except for the big_map. You only pay gas for the contents of the big_map when you GET (and maybe UNPACK) them.

Unfortunately, this seems to mean that, today, the most optimal way to write complex contracts (especially when they are the destination for internal transfers) will be to use big_map bytes bytes as storage, and to put all the code and storage inside the big_map, loading it on demand, using UNPACK.