Consumo di gas in una catena di trasferimenti interni

Nonpuoi superare hard_gas_limit_per_operation=400000. Tuttavia,probabilmente sarà aumentatonei protocollifuturi (vedi adesempio proposte" Atene ").

Itrasferimentiinternipossono consumaremoltogas.

Innanzitutto,èprevisto un costofisso di 10000gaspertrasferimento.

In secondo luogo,e cosapiùimportante,quando un contratto viene "analizzato",l'intero code e lo storage del contratto vengono letti dal database Tezos (adeccezione del big_map ). Paghiilgasin base alla dimensionebinaria dei dati letti. Anche l'intero codice viene "analizzato",in modo daestrarreiltipo diparametro del contrattoe confrontarlo coniltipoprevisto. Ciò accadein almeno duepunti:

1. Quando hai contractp neltuotipo di storage (al difuori di big_map ),il contratto verrà analizzatoprima che lo script vengaeseguito.
2. Quandoiltuo scriptesegue l'istruzione CONTRACTp Michelson,il contratto verrà analizzato.

Quindi,questo significa cheper TRASFERIRE_TOKENSin un contratto con script,ènecessario analizzarlo,pagandoilgasproporzionale al suo codicee alle dimensioni di archiviazione. Quandoil contratto riceveiltrasferimentoe viene caricatoperessereeseguito,questo costoe altro verrannopagati nuovamente ,prima ancora che lo script di destinazioneinizi aessereeseguito.

(Non è completamente necessario che lo storage venga letto dal database durante l'analisi di un contratto. Potremmo risolvere questoproblemabanalmentein unfuturo aggiornamento delprotocollo -e noi dovrebbe davvero,puòportare a vulnerabilitàmolto sorprendenti. Saràmenofacile risolvereilproblema con code ,mami aspetto che ungiorno verrà risolto,suddividendoil codicein piùpartinel database. Forse questopuò accadere quando aggiungiamopunti diingresso diprima classe.)

Quindi,unmodopermitigare questoproblema è assicurarsi che ogni contratto coinvolto abbia codicee spazio di archiviazione ridotti,adeccezione dibig_map. Paghi sologasperi contenuti dibig_map quando li OTTIENI (eforse DISIMBALLA ).

Sfortunatamente,questo sembra significare che,oggi,ilmodopiù ottimaleper scrivere contratti complessi (specialmente quando sono la destinazionepertrasferimentiinterni) sarà usare big_mapbytesbytes comememoriae permetteretuttoil codicee lo storage all'interno dibig_map,caricandolo su richiesta,utilizzando UNPACK.

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.