Script

Script é uma mini linguagem de programação usada como mecanismo de travamento das saídas nas transações de bitcoin.

• Um script de travamento (ScriptPubKey) é colocado em toda saída de transação.
• Um script de destravamento (ScriptSig ou Testemunha) precisa ser fornecido para destravar uma saída (ou seja, quando ela é usada como entrada em uma transação).

Se um script completo (destravamento + travamento) é válido, a saída é "destravada" e pode ser gasta.

A Linguagem Script

O que é Script?

Script é uma linguagem de programação bem básica. Ela consiste em duas coisas:

1. Opcodes – Funções simples que operam sobre dados.
2. Dados – Como chaves públicas e assinaturas.

Aqui está um diagrama simples de um script P2PKH típico usado no Bitcoin:

Interpretador de Script

Execute um script passo a passo e veja a pilha mudar a cada opcode. O ScriptSig roda primeiro, depois o ScriptPubKey.

Exemplo P2PK Exemplo P2PKH Exemplo P2MS

Script de Desbloqueio (ScriptSig) Script de Bloqueio (ScriptPubKey)

Executar Passo → Reiniciar

Script

—

Registro

Pilha

1. Opcodes

Aqui está uma lista rápida de todos os opcodes disponíveis na linguagem Script (junto com o byte hexadecimal correspondente usado para representar cada um).

• Opcodes destacados em vermelho foram desabilitados.
• Veja o Opcode Explained para informações detalhadas sobre o que cada opcode faz.
• Há também uma visão geral útil de todos os opcodes em bitcoin.it/wiki/.
• Não incluí os prefixos OP_ dos opcodes nos diagramas desta página.

2. Dados

Os elementos de dados dentro de um Script (ex.: chaves públicas, assinaturas) precisam ser empurrados manualmente para a pilha usando um opcode.

Há alguns opcodes específicos que você pode escolher para fazer isso, e o que você usa depende de quantos bytes você quer empurrar para a pilha.

OP_1

51

OP_PUSHBYTES_20
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

14aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

OP_PUSHDATA1
4c
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

4c4caaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

OP_PUSHDATA2
0001
aa... (256 bytes)

4d0001aa... (256 bytes)

OP_PUSHDATA4 00000100 [65536 bytes]

4e00000100[65536 bytes]

Por simplicidade, os diagramas desta página não mostram os opcodes OP_PUSHBYTES_X. Porém, essas operações de push são necessárias para empurrar dados para a pilha.

Operações de push mínimas

Você deve sempre usar a menor operação de push disponível para empurrar dados para a pilha.

Por exemplo, há várias formas de empurrar o número 8 para a pilha:

OP_8
OP_PUSHBYTES_1 08
OP_PUSHDATA1 01 08
OP_PUSHDATA2 0100 08
OP_PUSHDATA4 01000000 08

Da mesma forma, há várias formas de empurrar dois bytes para a pilha:

OP_PUSHBYTES_2 aaaa
OP_PUSHDATA1 02 aaaa
OP_PUSHDATA2 0200 aaaa
OP_PUSHDATA4 02000000 aaaa

A primeira operação em ambos os exemplos usa a menor quantidade de bytes para empurrar os dados para a pilha, e você deve sempre usar a opção mais eficiente que puder.

Essa regra foi introduzida no BIP 62 e é imposta pela função CheckMinimalPush() em script.cpp. Essa é uma regra de padronicidade (standardness), então, embora usar uma operação menos eficiente não torne o Script tecnicamente inválido, os nós não aceitarão na sua mempool nenhuma transação que use qualquer coisa diferente das operações de push mínimas.

Execução

Como um script é executado?

Um script completo é executado da esquerda para a direita. Conforme ele roda, faz uso de uma estrutura de dados chamada pilha (stack).

Os dados são empurrados para a pilha.

Os opcodes retiram elementos da pilha, fazem algo com eles e, então, opcionalmente, empurram novos elementos de volta para a pilha.

Validade

Um script completo é determinado como válido ou inválido depois que termina de ser executado.

Um script é válido se há um único* elemento não-zero deixado na pilha (ex.: OP_1).

Um script é inválido se:

1. A pilha final está vazia.
2. O único elemento deixado na pilha é OP_0.
3. Há mais de um elemento* deixado na pilha.
4. O script sai prematuramente (ex.: OP_RETURN).

Aqui está um exemplo da execução de um script P2PKH completo:

Localização

Onde o Script é usado no Bitcoin?

Um script de travamento (ScriptPubKey) é colocado em toda saída que você cria em uma transação:

Um script de destravamento (ScriptSig ou Testemunha) precisa ser fornecido para toda entrada que você quer gastar em uma transação:

Cada nó então combina e executa esses dois scripts para cada entrada de cada transação que recebe, para se certificar de que validam.

Se os scripts de destravamento das entradas não destravam com sucesso os scripts de travamento das saídas sendo gastas, então a transação é considerada inválida e não será retransmitida (nem minerada em um bloco).

O script de destravamento vem primeiro.

Embora o script de destravamento seja fornecido depois do script de travamento inicial (em termos de como as transações funcionam), na verdade colocamos o script de destravamento primeiro quando executamos o script completo.

Uso

Por que usamos Script no Bitcoin?

Por que usamos uma mini linguagem de programação para travar bitcoins? Por que não usar simplesmente uma comparação de chave pública e assinatura e abandonar todos esses opcodes e pilhas?

Bem, porque, usando Script, você pode criar diferentes tipos de travas usando diferentes combinações de OP_CODES.

Por exemplo, aqui estão alguns scripts de travamento legais que você pode criar:

1. Quebra-cabeça Matemático

Para gastar esta saída, você precisa fornecer dois números que somem 8.

Este pode não ser o script de travamento mais seguro do mundo, já que qualquer um pode descobri-lo e destravá-lo.

2. Quebra-cabeça de Hash

Aqui você só precisa de algo que faça hash com o mesmo resultado que está dentro do script de travamento.

3. Quebra-cabeça de Colisão de Hash

Este é bem legal. Você pode destravá-lo fornecendo duas strings de dados diferentes que produzam o mesmo resultado de hash.

Em outras palavras, ele funciona como um incentivo para encontrar uma "colisão de hash".

Este script de travamento em particular pode ser encontrado nesta saída. Porém, o script foi embrulhado em um script de travamento P2SH, então você não consegue de fato ver o script de travamento original (até que alguém o destrave).

Todos os scripts de travamento acima são não-padrão. Embora esses scripts sejam válidos (e possam ser minerados na blockchain), os nós típicos do Bitcoin Core não os retransmitem das suas memory pools, o que torna difícil que eles sejam minerados em primeiro lugar.

Scripts Padrão

Quais são os padrões de Script mais comuns no Bitcoin?

Apesar de ser possível criar uma variedade de scripts de travamento diferentes com várias combinações de OPCODES, a maioria dos nós só retransmite um punhado de "scripts padrão":

Legados

• P2PK (Pay To Public Key)
• P2PKH (Pay To Public Key Hash)
• P2MS (Pay To Multisig)
• P2SH (Pay To Script Hash)
• OP_RETURN

Esses eram os scripts padrão disponíveis no bitcoin entre 2009 e 2016 (antes da atualização Segwit).

Eles são destravados pelo campo ScriptSig.

Embora não sejam tão usados hoje (em favor dos scripts Segwit mais novos abaixo), eles ainda são perfeitamente válidos e você pode usá-los para travar as suas moedas, se quiser.

Segwit

• P2WPKH (Pay To Witness Public Key Hash)
• P2WSH (Pay To Witness Script Hash)
• P2TR (Pay To Taproot)

Esses scripts padrão foram introduzidos após a atualização Segwit em 2016 e a atualização Taproot em 2021. Foram basicamente introduzidos para substituir os scripts de travamento legados P2PKH e P2SH acima.

Eles são destravados pelo campo de Testemunha.

Esses scripts de travamento não usam, de fato, a linguagem Script completa.

Em vez disso, cada script de travamento tem o seu próprio padrão específico, e eles são executados de uma forma fixa internamente ao serem destravados. Então, de certa forma, eles abandonaram a linguagem Script (exceto quando você embrulha um script completo dentro de um P2WSH).

Então, quando eu disse "por que não usar simplesmente uma comparação de chave pública e assinatura e abandonar todos esses opcodes e pilhas?", bem, é exatamente isso que esses scripts fizeram.

Limites

Qual é o tamanho máximo de um script?

Os scripts no bitcoin têm certos limites no seu tamanho. Há dois tipos de limite:

1. Limites de Validade. Qualquer transação que contenha um script que exceda esses limites será considerada inválida. Isso significa que ela será rejeitada pelos nós e não poderá ser minerada na blockchain.
2. Limites de Padronicidade. Uma transação pode quebrar esses limites e ainda ser minerada na blockchain, mas os nós a considerarão não-padrão e se recusarão a retransmiti-la entre as memory pools.

1. Limites de Validade

• O tamanho máximo de um script é 10.000 bytes. Um ScriptPubKey + ScriptSig combinados não podem ser maiores que 10.000 bytes.
• O número máximo de OP_CODES é 201. Esse limite não inclui as operações que empurram dados para a pilha.
• O tamanho máximo de um único elemento é 520 bytes. Você não pode empurrar nenhum dado para a pilha que exceda 520 bytes. Esse limite é mais relevante ao construir um Redeem Script para um P2SH, já que um Redeem Script é um empilhamento de dados de um script.
• O número máximo de itens na pilha é 1.000. Um script completo pode conter mais de 1.000 elementos, mas você não pode construir um script que empurre mais de 1.000 itens para a pilha em um dado momento.

Esses limites podem ser encontrados em script.h.

Esses limites só se aplicam durante a execução do script. Então você poderia colocar em uma saída um ScriptPubKey que excedesse esses limites e ele seria minerado. Mas, quando você fosse tentar gastá-lo como entrada (ou seja, quando o script estivesse sendo executado), a transação de gasto seria considerada inválida. Em outras palavras, a saída seria não gastável.

2. Limites de Padronicidade

• O ScriptSig pode ter no máximo 1.650 bytes. Então, se você precisa usar mais de 1.650 bytes de dados e/ou OP_CODES para destravar uma saída, os nós não retransmitirão a sua transação.
• O ScriptPubKey não tem limite (a não ser estar restrito pelo limite de tamanho do bloco). Então é perfeitamente normal criar um ScriptPubKey ridiculamente grande, se você quiser, mas lembre-se de que ele será não gastável se exceder qualquer um dos limites de validade acima.

Então, embora seja válido para uma transação exceder esses limites, será difícil minerá-la na blockchain, a não ser que você consiga minerá-la você mesmo ou que um minerador a adicione à blockchain para você.

Esses limites podem ser encontrados em policy.h.

Resumo

Em poucas palavras

Script é apenas uma mini linguagem de programação usada no Bitcoin para fornecer o mecanismo de travamento das saídas.

• Toda saída recebe um "script de travamento".
• Você precisa então fornecer um "script de destravamento" na transação que quer gastar aquela saída.

Quando um nó recebe a transação de gasto, ele combina esses dois scripts e os executa. Se um OP_1 (e nada além disso) é deixado no topo da pilha após o script terminar de executar, então o script é válido e a saída pode ser gasta.

Os scripts de travamento segwit mais novos se afastaram um pouco do uso do Script tradicional, mas a linguagem Script ainda é usada para os scripts de travamento legados e também pode continuar sendo usada dentro do script de travamento P2WSH mais novo.

Recursos

• Opcode Explained – Um guia completo sobre os opcodes e o que cada um faz.
• bitcoin.it/wiki/Script
• The Bitcoin Script language (pt.1)
• Mastering Bitcoin: Capítulo 7 (Autorização e Autenticação)
• Um script é gastável se múltiplos itens são deixados na pilha?
• Por que transações não-padrão podem ser mineradas mas não retransmitidas?
• isStandard()
• Minsc — Uma ferramenta útil para construir scripts de Bitcoin complexos usando uma linguagem de alto nível baseada em Miniscript.