W03.02 – SCRIPT BITCOIN


WEEK 3
Mechanics of Bitcoin

Learn how the individual components of the Bitcoin protocol make the whole system tick: transactions, script, blocks, and the peer-to-peer network. Scopri in che modo i singoli componenti del protocollo Bitcoin fanno funzionare l’intero sistema: transazioni, script, blocchi e la rete peer-to-peer.

Joseph Bonneau
Postdoctoral Research Associate – Princeton University

Sezione 03.02 – Script Bitcoin
03.02.0
Okay, so like we said each transaction output doesn’t just specify a simple public key, it actually specifies a script. So what do I mean by that, what is a script and why do we use scripts? In this section we’re going to talk about what the Bitcoin scripting language is, and why script is used instead of simply assigning a public key. Bene, come abbiamo detto ogni output di transazione non specifica solo una semplice chiave pubblica, ma specifica effettivamente uno script. Quindi cosa intendo con questo, cos’è uno script e perché utilizziamo gli script? In questa sezione parleremo di cosa sia il linguaggio di scripting di Bitcoin e perché venga usato lo script invece di assegnare semplicemente una chiave pubblica.
03.02.01
Okay, so to understand scripts, I think the easiest way by an example. And we’ll take as an example the most common script in Bitcoin, which is to redeem a previous transaction by signing with the correct public key.

So this is what the output address would look like in that case. The output address is really a script. In this case the script is gonna have four instructions so what happens to this script? Who runs it? How does the script indicate who has the ability to spend these coins? The secret is that the input address is also a script.
Va bene, quindi per capire gli script, penso che il modo più semplice sia un esempio. E prenderemo come esempio lo script più comune in Bitcoin, che è quello di riscattare una transazione precedente firmando con la chiave pubblica corretta.

Quindi questo è l’indirizzo di output in questo caso. L’indirizzo di output è davvero uno script. In questo caso lo script avrà quattro istruzioni, quindi cosa succede a questo script? Chi lo gestisce? In che modo lo script indica chi ha la possibilità di spendere queste monete? Il segreto è che l’indirizzo di input è anche uno script.
03.02.02
So that’s a bit of script that you combine with the output address, you simply concatenate them and that gets you one script that has to run successfully in order to claim a Bitcoin.

So traditionally, these two scripts are called scriptSig and scriptPubKey, and that’s because in the simplest case, the output script just specifies the public key, and the input script specifies a signature with that public key.
Quindi questo è un po’ di script che si combina con l’indirizzo di output, semplicemente li si concatena e si ottiene uno script che deve essere eseguito correttamente per rivendicare un Bitcoin.

Quindi, tradizionalmente, questi due script sono chiamati scriptSig e scriptPubKey, e questo perché nel caso più semplice, lo script di output specifica solo la chiave pubblica, e lo script di input specifica una firma con quella chiave pubblica.
03.02.03
When a transaction is being validated, the two scripts get pasted together, they get run, and if the concatenated script can run without an errors, this is considered a valid transaction. Quando una transazione viene convalidata, i due script vengono incollati insieme, vengono eseguiti e se lo script concatenato può essere eseguito senza errori, questa viene considerata una transazione valida.
03.02.04
So, where did this scripting language come from?

It doesn’t really have a proper name. It’s just called Script or the Bitcoin scripting language, and it was built specifically for Bitcoin. It was probably most inspired by a language called Forth, which is an old stack-based simple programming language, but you don’t need to understand Forth to understand Bitcoin scripting.

The key design properties here were to have something that was quite simple, quite compact, but yet had support for pretty sophisticated cryptography. So there are special purpose instructions to do compute hash functions, and to compute signatures and verify signatures.

And this is a stack-based language. And you may have never seen a stack-based language before in your life. But I’ll explain in the next slide what that means and why that was chosen. So there are a lot of limits here that are important to keep in mind. In particular there are no loops in the Bitcoin scripting language. Every instruction is executed exactly once in a linear manner. So if you look at a script, just based on the number of instructions in the
script, you know exactly how long it might take to run and how much memory it could use.So this is not a turning complete language.

It doesn’t have the ability to compute arbitrarily powerful functions. And this is by design, because the miners have to run these scripts which are submitted by arbitrary participants in the network. So you don’t want to give them the power to submit a script that might have an infinite loop or might run forever.

And since it’s not a turning complete language, we don’t have the halting problem. You can look at any Bitcoin script and be sure that it’s going to terminate within a finite number of steps, which is just the number of instructions that are in that script.
Quindi, da dove viene questo linguaggio di scripting?

Non ha un nome proprio. Si chiama Script o il linguaggio di script Bitcoin ed è stato creato appositamente per Bitcoin. Probabilmente è stato più ispirato da un linguaggio chiamato Forth, che è un vecchio linguaggio di programmazione semplice basato su stack, ma non è necessario comprendere Forth per comprendere lo script di Bitcoin.

Le proprietà chiave del design qui erano di avere qualcosa che fosse abbastanza semplice, abbastanza compatto, ma che avesse tuttavia supporto per la crittografia piuttosto sofisticata. Quindi ci sono istruzioni speciali per fare funzioni di hash di calcolo, e per calcolare le firme e verificare le firme.

E questo è un linguaggio basato sullo stack. E forse non hai mai visto un linguaggio basato sullo stack prima nella tua vita. Ma spiegherò nella prossima slide cosa significa e perché è stato scelto. Quindi ci sono molti limiti qui che sono importanti da tenere a mente. In particolare, non ci sono loop nel linguaggio di scripting di Bitcoin. Ogni istruzione viene eseguita esattamente una volta in modo lineare. Quindi, se guardi uno script, basandosi solo sul numero di istruzioni nello script, sai esattamente quanto tempo ci vuole per eseguire e quanta memoria può usare.
Quindi questo non è un linguaggio completo.

Non ha la capacità di calcolare funzioni arbitrariamente potenti. E questo è in base alla progettazione, perché i minatori devono eseguire questi script inviati da partecipanti arbitrari nella rete. Quindi non vuoi dare loro il potere di presentare uno script che potrebbe avere un ciclo infinito o potrebbe essere eseguito per sempre.

E dal momento che non è un linguaggio completo, non abbiamo il problema di fermarsi. Puoi guardare qualsiasi script Bitcoin ed essere sicuro che finirà con un numero finito di passaggi, che è solo il numero di istruzioni contenute in quello script.
03.02.05
Okay, now the fun part. We’re gonna look at a specific Bitcoin script, and exactly how it’s executed.

This is the same example as before, this is the most common script in Bitcoin.

A script where the sender of coins simply specifies the public key of the recipient, and the recipient of the coins, to redeem them, has to specify a signature using that specified public key.

So, the first two instructions in this script are simply data instructions, like I said, and these are the signature and the public key used to generate that signature and these were specified by the recipient in that script sig component or the input script.

So executing data instructions is easy in a stack based language. If you see data, you just pushed it unto the stack.

And that’s the only interaction with memory that you have with a stack based programming language.

There’s no variables, there’s only a stack, so the only thing you can do to write data to memory is to push it onto the stack.

So after we’ve pushed those two values onto these stack, we’re gonna start executing the second half of the script which was specified by the sender of the coins. So this is the script pubKey component of the script.
And now we’re gonna start to actually manipulate some of those values on the stack.
Ok, ora la parte divertente. Guarderemo uno specifico script Bitcoin esattamente come viene eseguito.

Questo è lo stesso esempio di prima, questo è lo script più comune in Bitcoin.

Uno script in cui il mittente di monete specifica semplicemente la chiave pubblica del destinatario e il destinatario delle monete, per riscattarle, deve specificare una firma usando quella chiave pubblica specificata.

Quindi, le prime due istruzioni in questo script sono semplicemente le istruzioni dei dati, come ho detto, e questi sono la firma e la chiave pubblica utilizzata per generare quella firma e questi sono stati specificati dal destinatario in quel componente di script o nello script di input.

Quindi l’esecuzione delle istruzioni sui dati è facile in un linguaggio basato sullo stack. Se vedi i dati, li hai semplicemente messi in pila.

E questa è l’unica interazione con la memoria che hai con un linguaggio di programmazione basato su stack.
Non ci sono variabili, c’è solo uno stack, quindi l’unica cosa che puoi fare per scrivere i dati in memoria bisogna metterli in pila.

Quindi, dopo aver spinto questi due valori su questi stack, inizieremo a eseguire la seconda parte dello script che è stata specificata dal mittente delle monete. Quindi questo è lo script pubKey componente dello script.
E ora inizieremo a manipolare effettivamente alcuni di quei valori in pila.
03.02.06
So this duplicate instruction, OP_DUP, says, simply take the value that’s on the top of the stack, pop it off, and then write two copies back to the stack.

So we’re just gonna duplicate that public key.

The next instruction, HASH160, says, take the top value on the stack and compute a cryptographic hash of it.

So this top value is going to be converted from the public key into a hash of the public key. Now we are going to do one more push of data onto this stack, and this data, remember, was specified by the sender of the coins.
Quindi, questa istruzione duplicata, OP_DUP, dice, semplicemente prendi il valore che si trova in cima allo stack, espellilo e poi scrivi di nuovo due copie nello stack.

Quindi duplicheremo quella chiave pubblica.

L’istruzione successiva, HASH160, dice, prende il valore più alto in pila e calcola un hash crittografico di esso.

Quindi questo valore superiore sarà convertito dalla chiave pubblica in un hash della chiave pubblica. Ora faremo un’altra spinta di dati su questo stack, e questi dati, ricordo, sono stati specificati dal mittente delle monete.
03.02.07
So this is the public key that the sender specified, had to be used to generate the signature to redeem these coins.

So now at the top of this stack we have two values, we have the hash of the public key specified by the sender. And the hash of the public key that was actually used by the recipient when trying to claim the coins.

And we’ll just run this equal verify command, which just says are the two values at the top of the stack equal.
If they aren’t, an error’s gonna be thrown and the script will stop executing.
Quindi questa è la chiave pubblica che il mittente ha specificato, doveva essere usata per generare la firma per riscattare queste monete.

Ora, in cima a questo stack abbiamo due valori, abbiamo l’hash della chiave pubblica specificata dal mittente. E l’hash della chiave pubblica che è stata effettivamente utilizzata dal destinatario quando si tenta di rivendicare le monete.

E eseguiremo semplicemente questo comando di verifica uguale, che dice solo che i due valori in cima alla pila sono uguali. Se non lo sono, verrà generato un errore e lo script smetterà di essere eseguito.
03.02.08
But we’ll assume that they are. We’ll assume that the recipient of the coins actually did use the correct public key.

That instruction will consume those two data items that are at the top of the stack. So now we’re left with two data items on the stack.

A signature and a public key. And we’ve already checked that the public key was the right public key that was specified by the sender of these coins. And now we wanna check that the signature is actually valid. So this is where the power of the Bitcoin scripting language really comes into play. There’s one instruction here that lets you verify a signature. So it’s easy to write scripts that do signature verification without calling any special library to check the signatures. That’s all built in to the Bitcoin scripting language.

Now one thing I haven’t told you is what is this actually a signature of. What was the input to the signature function?

And it turns out there’s only one thing you can sign in Bitcoin which is an entire transaction. So this check sig instruction is going to verify that the entire transaction was successfully signed.

So in just one go, hopefully the check sig instruction will pop those remaining two items off of the stack, check that the signature is valid. And now we’ve executed every instruction in the script, there’s nothing left on the stack, and if we haven’t had any errors, the output of this script will be a simple yes. So every Bitcoin script can only produce two outcomes. It can either execute successfully with no errors, in which case the transaction is valid. If there’s any error while the script is executing, the whole transaction will be invalid and shouldn’t be accepted into the block chain.
Ma supponiamo che lo siano. Assumiamo che il destinatario delle monete abbia effettivamente utilizzato la chiave pubblica corretta.

Quelle istruzioni consumeranno quei due elementi di dati che sono in cima alla pila. Così ora ci rimangono due elementi di dati nello stack.

Una firma e una chiave pubblica. E abbiamo già controllato che la chiave pubblica fosse la chiave pubblica corretta specificata dal mittente di queste monete. E ora vogliamo verificare che la firma sia effettivamente valida. Quindi è qui che entra in gioco la potenza del linguaggio di scripting Bitcoin. C’è un’istruzione qui che ti consente di verificare una firma. Quindi è facile scrivere script che eseguono la verifica della firma senza chiamare alcuna libreria speciale per controllare le firme. Tutto ciò è integrato nel linguaggio di scripting di Bitcoin.

Ora una cosa che non ti ho detto è di che cosa si tratti effettivamente. Qual è stato l’input per la funzione di firma?

E si scopre che c’è solo una cosa che puoi firmare in Bitcoin che è un’intera transazione. Quindi questa istruzione di controllo sig verificherà che l’intera transazione è stata firmata con successo.

Quindi, con un solo go, si spera che l’istruzione di controllo sig sposterà i restanti due elementi fuori dallo stack, verificando che la firma sia valida. E ora abbiamo eseguito tutte le istruzioni nello script, non è rimasto nulla nello stack e, se non abbiamo avuto errori, l’output di questo script sarà un sì semplice. Quindi ogni script Bitcoin può produrre solo due risultati. Può essere eseguito correttamente senza errori, nel qual caso la transazione è valida. Se c’è un errore mentre lo script è in esecuzione, l’intera transazione non sarà valida e non dovrebbe essere accettata nella catena dei blocchi.
03.02.09
So a little bit more about the Bitcoin scripting language.

It’s very small, there’s only room for 256 instructions, cuz each one is given one byte. And of those 15 of them are currently disabled, so you can’t use them at all. And 75 of them are reserved.
So haven’t been assigned any specific meaning yet. But might be instruction that are added later in time. So there’s a lot of the basic instructions that you’d expect in any programming language are gonna be there. There’s basic arithmetic, basic logic like, if and then. Throwing errors, not throwing errors, returning early. And finally there are crypto instructions like I said. So there are hash functions, instructions for signature verification, and there’s a special, very important instruction for multi-signature verification.
Un po’ di più sul linguaggio di scripting Bitcoin.

È molto piccolo, c’è solo spazio per 256 istruzioni, perché a ciascuno viene dato un byte. E di questi 15 sono attualmente disabilitati, quindi non li puoi usare affatto. E 75 di loro sono riservati.
Quindi non è stato ancora assegnato alcun significato specifico. Ma potrebbero essere istruzioni che verranno aggiunte più avanti nel tempo. Quindi ci sono molte delle istruzioni di base che ti aspetteresti in qualsiasi linguaggio di programmazione ci saranno. C’è l’aritmetica di base, la logica di base come, if and then. Errori di lancio, non errori di lancio, ritorno anticipato. E infine ci sono istruzioni cripto come ho detto. Quindi ci sono funzioni hash, istruzioni per la verifica della firma e c’è un’istruzione speciale molto importante per la verifica multi-firma.
03.02.10
That’s called CHECKMULTISIG. So, this even more powerful than checking just the single signature with one instruction. Bitcoin actually lets you check multiple signatures with one instruction.

So, with MULTISIG you specify n public keys, and you specify a parameter t or a threshold, and for this instruction to execute validly, there have to be at least t signatures, t out of n of those public keys, that are valid.

So we’ll show some examples of what you use MULTISIG for in a second, but it is quite a powerful primitive that in a compact way in the Bitcoin scripting language, you can express the concept that t out of n of these public keys must sign in order for this transaction to be valid.

So there’s an important bug here. There’s a gotcha, which has been there since the beginning of time, which is that in the original implementation of this, the CHECKMULTISIG instruction actually pops an extra data value off the stack and ignores it. So this is just a quirk of the Bitcoin language. It’s something that, in programming, you have to deal with by putting an extra dummy variable on to the stack. And at this point it’s considered a feature in Bitcoin and that it’s not going away. The costs of removing it are much higher than the damage it causes, so this is just a fun bug that everybody in the Bitcoin community gets to live with.
Questo si chiama CHECKMULTISIG. Quindi, questo è ancora più potente del controllo della singola firma con una sola istruzione. Bitcoin consente di controllare più firme con una sola istruzione.

Quindi, con MULTISIG si specificano n chiavi pubbliche e si specifica un parametro t o una soglia e, affinché questa istruzione sia eseguita correttamente, devono esserci almeno t firme, t out di n di quelle chiavi pubbliche, che sono valide.

Quindi mostreremo alcuni esempi di cosa usi MULTISIG in un secondo, ma è piuttosto un primitivo potente che in modo compatto nel linguaggio di scripting Bitcoin, puoi esprimere il concetto che t di n di queste chiavi pubbliche deve essere firmato affinché questa transazione sia valida.

C’è un bug importante qui. C’è un gotcha, che è stato presente fin dall’inizio del tempo, ovvero che nell’implementazione originale di questo, l’istruzione CHECKMULTISIG apre effettivamente un valore di dati extra dallo stack e lo ignora. Quindi questo è solo un capriccio del linguaggio Bitcoin. È qualcosa che, nella programmazione, devi affrontare mettendo una variabile dummy extra in pila. E a questo punto è considerato una funzionalità in Bitcoin e che non sta andando via. I costi per rimuoverlo sono molto più alti del danno che provoca, quindi questo è solo un bug divertente con cui tutti i membri della comunità Bitcoin convivono.
03.02.11
So like I’ve said we have this whole scripting language that let’s us specify, in some sense arbitrary conditions that must be met in order to spend coins. But as of today this isn’t used very heavily. So if you look at the history of Bitcoin and look at what scripts have actually been used the vast majority, 99.9%, are exactly the same script. Which is in fact the script I showed you in our example of a script execution. A script that just specifies one public key, and requires a signature for that public key in order to spend the coins.

There’s a few other things that have some use. So MULTISIG gets used a little bit and there is a special type of script called Pay-to-Script-Hash that I’ll talk about in just a minute. But other than that there hasn’t been too much creativity in terms of what scripts people actually use.

And one reason for that is that Bitcoin nodes by default, have a white list of scripts and they refuse to accept scripts that they consider not standard. This doesn’t mean that those scripts can’t be used at all, it just makes them harder to use, and I’ll talk about exactly what that means a little bit later when we talk about the Bitcoin peer-to-peer network.
Così come ho detto che abbiamo questo intero linguaggio di scripting che ci permette di specificare, in un certo senso alcune condizioni arbitrarie devono essere soddisfatte al fine di spendere monete. Ma a partire da oggi questo non viene usato molto di frequente. Quindi, se si guarda alla storia di Bitcoin e si guarda a quali script sono stati effettivamente utilizzati, la stragrande maggioranza, il 99,9%, è esattamente lo stesso script. Che è in effetti lo script che ti ho mostrato nel nostro esempio di un’esecuzione di script. Uno script che specifica solo una chiave pubblica e richiede una firma per questa chiave pubblica per spendere le monete.

Ci sono alcune altre cose che hanno qualche utilità. Quindi MULTISIG si abitua un po’ e c’è uno speciale tipo di script chiamato Pay-to-Script-Hash di cui parlerò fra un minuto. Ma a parte questo non c’è stata troppa creatività in termini di ciò che gli script usano effettivamente.

E una delle ragioni è che i nodi Bitcoin di default hanno una lista bianca di script e rifiutano di accettare script che considerano non standard. Questo non significa che quegli script non possano essere usati affatto, li rende solo più difficili da usare, e parlerò esattamente di ciò che significa un po’ più tardi quando parliamo della rete peer-to-peer di Bitcoin.
03.02.12
Okay, so I mentioned that some of the scripts are what we call proof-of-burn. So proof-of-burn is actually a script that can never be redeemed. So if you have a proof -of-burn script, It’s provable that those coins have been destroyed, there’s no possible way for them to be spent. This is quite simple to implement. You just use this code, OP_RETURN, which throws an error if it’s ever reached, and what no matter what values you put before then, that instruction will get executed eventually, in which case this program will crash. The data comes after OP_RETURN is never going to be looked at, so this is an opportunity for people to specify arbitrary data in a script.

So what is the point of proof-of-burn.

Well, there is two main things that this gets used for.

The first is to write arbitrary data into the block chain if for some reason you want to write your name, or if you want to time stamp and prove that you knew some data at a specific time, you can create a very low value Bitcoin transaction that’s proof-of-burn. So you can destroy a very small amount of currency, and in exchange you can write whatever you want into the block chain, which should be kept around forever.

The other example of proof-of-burn we’ll talk about in a later lecture on alternate currencies, that it can be way to bootstrap an alternative to Bitcoin by forcing people to destroy Bitcoin in order to gain coins in the new system.
Okay, quindi ho detto che alcuni degli script sono ciò che chiamiamo proof-of-burn. Quindi proof-of-burn è in realtà uno script che non può mai essere riscattato. Quindi, se hai uno script proof-of-burn, è dimostrabile che quelle monete sono state distrutte, non c’è modo per loro di essere spese. Questo è abbastanza semplice da implementare. Devi solo usare questo codice, OP_RETURN, che genera un errore se è mai stato raggiunto, e quale che sia il valore che hai inserito prima, quella istruzione verrà eseguita alla fine, nel qual caso questo programma andrà in crash. I dati arrivano dopo che OP_RETURN non verrà mai esaminato, quindi questa è un’opportunità per le persone di specificare dati arbitrari in uno script.

Quindi qual è il punto di proof-of-burn.

Bene, ci sono due cose principali per cui questo viene usato.

Il primo è scrivere dati arbitrari nella catena di blocchi se per qualche ragione vuoi scrivere il tuo nome, o se vuoi segnare il tempo e dimostrare di conoscere alcuni dati in un momento specifico, puoi creare un valore molto basso valore transazione Bitcoin che è proof-of-burn. Quindi puoi distruggere una piccola quantità di valuta, e in cambio puoi scrivere qualunque cosa tu voglia nella catena dei blocchi, che dovrebbe restare in giro per sempre.

L’altro esempio di proof-of-burn di cui parleremo in una lezione successiva su valute alternative, che può essere un modo per avviare un’alternativa a Bitcoin costringendo le persone a distruggere Bitcoin per guadagnare monete nel nuovo sistema.
03.02.13
So one thing that’s funny about this is that the sender of coins has to specify the script exactly. So this might be funny if you’re a consumer, you’re shopping online, you’re about to order something. And you say all right, I’m ready to check out, I’m ready to pay, tell me the address where I should send my coins. And the retailer came back and said oh, well, we’re doing something fancy now. We’re using MULTISIG, we’re going to ask you to send the coins to some complicated script.

You might say, I don’t know how to do that. That’s too complicated. As a consumer, I just want to send to a very simple address.
Una cosa che è divertente è che il mittente di monete deve specificare esattamente lo script. Quindi questo potrebbe essere divertente se sei un consumatore, stai acquistando online, stai per ordinare qualcosa. E tu dici tutto bene, sono pronto a dare un’occhiata, sono pronto a pagare, dimmi l’indirizzo dove dovrei spedire le mie monete. E il rivenditore è tornato e ha detto oh, beh, stiamo facendo qualcosa di sofisticato ora. Stiamo usando MULTISIG, ti chiederemo di inviare le monete a uno script complicato.

Potresti dire che non so come farlo. È troppo complicato. Come consumatore, voglio solo inviare a un semplice indirizzo.
03.02.14
So in response to that problem, there’s a really clever hack in Bitcoin, which is that instead of having the sender specify the entire script, the sender can specify just a hash of the script that is gonna be needed to redeem those coins.

So this looks like the sender specifying a very simple script which just hashes the top value on the stack and checks to see if it’s equal to the required redemption script.

So the receiver of those coins, all they have to do, it looks like It’s just specify the right script, and then this transaction will verify. So the basic script is very easy to satisfy here. The receiver just has to specify, as a data value, the value of the script that whose hash the sender specified.

But after this happens, a special second step of validation is going to occur.

Where that top data value from the stack is going to be reinterpreted as instructions, and then it’s gonna be executed a second time as a script. So you see there were two stages that happened here, first there was this traditional script which checked that the redemption script had the right hash and then the redemption script will be deserialized and run as a script itself. And here’s where the actual signature check is going to happen.
Quindi, in risposta a questo problema, c’è un trucco molto intelligente in Bitcoin, quello che il mittente invece di specificare l’intero script, può specificare solo un hash dello script che sarà necessario per riscattare tali monete.

Questo assomiglia al mittente specificando uno script molto semplice che semplicemente ha il valore più alto nello stack e controlla se è uguale allo script di richiesta richiesto.

Quindi, il ricevitore di quelle monete, tutto quello che deve fare, sembra che sia solo specificare lo script giusto, e quindi questa transazione verrà verificata. Quindi lo script di base è molto facile da soddisfare qui. Il ricevitore deve solo specificare, come valore di un dato, il valore dello script il cui hash è stato specificato dal mittente.

Ma dopo che questo è accaduto, si verificherà un secondo passo speciale di convalida.

Dove il valore di dati superiore dello stack sta andando da reinterpretare come istruzioni, e poi verrà eseguito una seconda volta come script. Quindi vedi che c’erano due fasi qui, prima c’era questo script tradizionale che controllava che lo script di redemption aveva il giusto hash e quindi lo script di redemption verrà deserializzato ed eseguito come uno script stesso. Ed ecco dove si verificherà l’effettivo controllo della firma.
03.02.15
So this is called pay to script hash in Bitcoin, as an alternative to the normal mode of operation, which is pay to a public key.

And the reason this was so complicated is that this was added to Bitcoin after the fact. This wasn’t part of the initial design specification. This is probably the most notable feature that’s been added to Bitcoin that wasn’t there in the original specification.
Questo è chiamato pay to script hash di in Bitcoin, come alternativa alla normale modalità di funzionamento, che è pagata a una chiave pubblica.

E il motivo per cui questo è stato così complicato è che questo è stato aggiunto a Bitcoin dopo. Questo non faceva parte delle specifiche di progettazione iniziali. Questa è probabilmente la caratteristica più importante che è stata aggiunta a Bitcoin che non era presente nelle specifiche originali.
03.02.16
And it solves a couple of important problems.

It removes complexity from the sender, so the recipient can just specify a hash that the sender sends money to. And it actually has a nice efficiency gain as we’ll talk about later, since minors have to track the set of output scripts that haven’t been redeemed yet. The output scripts are now as small as possible with pay to script hash. Cuz they just specify a hash, and all of the complexity is pushed to the input scripts.
E risolve un paio di importanti problemi.

Rimuove la complessità dal mittente, quindi il destinatario può semplicemente specificare un hash cui il mittente invia soldi. E in realtà ha un buon guadagno di efficienza di cui parleremo in seguito, poiché i minori devono tenere traccia dell’insieme di script di output che non sono stati ancora riscattati. Gli script di output sono ora i più piccoli possibile con l’hash pay to script. Perché essi specificano solo un hash e tutta la complessità è spinta agli script di input.

[top]
© Joseph Bonneau – Postdoctoral Research Associate – Princeton University

W03.01
Transazioni Bitcoin
W03.03
Applicazione di Script Bitcoin