O Que São Scripts no Bitcoin?

Introdução

Scripts são o coração do sistema de transações Bitcoin. Eles definem condições que precisam ser satisfeitas para gastar Bitcoin e são fundamentais para entender como transações realmente funcionam. Este guia vai explicar o que são ScriptPubKey, ScriptSig, opcodes, e como eles se combinam para criar transações Bitcoin válidas.

Importante: Este é um guia de nível avançado. Assumimos conhecimento básico de transações Bitcoin, UTXOs, e conceitos de criptografia. Se você é iniciante, recomendamos primeiro entender como transações funcionam antes de avançar para este conteúdo técnico sobre scripts.

Ao final deste guia, você entenderá como scripts funcionam, como ScriptPubKey e ScriptSig se combinam, quais opcodes são usados, e como a estrutura de scripts define quem pode gastar Bitcoin.

O Que São Scripts?

Conceito Básico

Script é uma linguagem de programação simples e empilhada (stack-based) usada no Bitcoin para definir condições de gasto.

Características principais:

Não é Turing-completa: Não pode fazer loops infinitos
Baseada em stack: Operações funcionam em uma pilha
Determinística: Sempre produz mesmo resultado
Limitada: Poucos opcodes disponíveis
Segura: Impossível criar scripts maliciosos que travem a rede

Por que scripts existem?:

Definem quem pode gastar Bitcoin
Permitem diferentes tipos de transações
Base para funcionalidades avançadas (multisig, timelocks, etc.)
Flexibilidade sem complexidade excessiva

Analogia simples:

Como uma fechadura (ScriptPubKey) que precisa de chave correta (ScriptSig)
Script verifica se "chave" abre "fechadura"
Se sim, transação é válida
Se não, transação é rejeitada

Estrutura de Scripts em Transações

Em uma transação Bitcoin, scripts aparecem em dois lugares:

1. ScriptPubKey (script de bloqueio):

Define condições para gastar output
Fica no output de uma transação
Como uma "fechadura"

2. ScriptSig (script de desbloqueio):

Fornece dados para satisfazer ScriptPubKey
Fica no input de uma transação
Como uma "chave"

Combinação:

ScriptSig + ScriptPubKey = script completo
Script completo é executado para validar transação
Se execução é bem-sucedida, transação é válida

ScriptPubKey: A Fechadura

O Que É ScriptPubKey?

ScriptPubKey é o script que define condições para gastar um output (UTXO).

Características:

Bloqueia Bitcoin: Define quem pode gastar
Permanece na blockchain: Fica registrado permanentemente
Pode ser simples ou complexo: Desde scripts simples até multisig avançados
Não pode ser mudado: Uma vez criado, é imutável

Onde fica:

No output de uma transação
Parte do UTXO até ser gasto
Visível na blockchain para sempre

Tipos Comuns de ScriptPubKey

1. P2PKH (Pay to Public Key Hash):

ScriptPubKey: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG

O que faz:

Verifica assinatura com chave pública
Verifica hash da chave pública
Formato mais comum em transações simples

2. P2SH (Pay to Script Hash):

ScriptPubKey: OP_HASH160 <scriptHash> OP_EQUAL

O que faz:

Permite scripts mais complexos
Hash de script, não script completo
Mais flexível

3. P2WPKH (Pay to Witness Public Key Hash - SegWit):

ScriptPubKey: OP_0 <witnessPubKeyHash>

O que faz:

Versão SegWit de P2PKH
Dados de witness separados
Taxas menores

4. P2WSH (Pay to Witness Script Hash - SegWit):

ScriptPubKey: OP_0 <witnessScriptHash>

O que faz:

Versão SegWit de P2SH
Scripts complexos com witness separado
Taxas menores

Exemplo Simplificado de ScriptPubKey

ScriptPubKey P2PKH simples:

OP_DUP
OP_HASH160
<20 bytes: hash da chave pública>
OP_EQUALVERIFY
OP_CHECKSIG

O que cada parte faz:

OP_DUP: Duplica item no topo da stack
OP_HASH160: Faz hash SHA-256 seguido de RIPEMD-160
<20 bytes>: Hash da chave pública do destinatário
OP_EQUALVERIFY: Verifica se dois itens são iguais
OP_CHECKSIG: Verifica assinatura

Significado:

"Para gastar este Bitcoin, você precisa fornecer chave pública que tem este hash E assinatura válida"

ScriptSig: A Chave

O Que É ScriptSig?

ScriptSig é o script que fornece dados para satisfazer condições do ScriptPubKey.

Características:

Desbloqueia Bitcoin: Fornece dados necessários
É gasto após uso: Não fica na blockchain permanentemente (exceto em casos especiais)
Deve corresponder: Deve satisfazer condições do ScriptPubKey
Contém assinatura: Geralmente contém assinatura digital

Onde fica:

No input de uma transação
Fornecido quando gastando UTXO
Removido após validação (em SegWit)

Estrutura de ScriptSig

ScriptSig típico para P2PKH:

<scriptSig> = <signature> <publicKey>

Componentes:

Assinatura: Assinatura digital da transação
Chave pública: Chave pública correspondente à chave privada que assinou

Exemplo simplificado:

<71 bytes: assinatura>
<33 bytes: chave pública>

Como ScriptSig Satisfaz ScriptPubKey

Processo de validação:

1. ScriptSig é executado primeiro:

Coloca assinatura e chave pública na stack

2. ScriptPubKey é executado depois:

Usa dados deixados por ScriptSig
Verifica condições
Retorna verdadeiro ou falso

3. Se tudo passar:

Transação é válida
Output pode ser gasto

Se algo falhar:

Transação é rejeitada
Output não pode ser gasto

Opcodes: A Linguagem dos Scripts

O Que São Opcodes?

Opcodes são as instruções da linguagem de script Bitcoin.

Tipos de opcodes:

1. Constantes:

Colocam dados na stack
Exemplo: <0x41> coloca byte 0x41 na stack

2. Operações de Stack:

Manipulam stack
Exemplos: OP_DUP, OP_DROP, OP_SWAP

3. Operações Aritméticas:

Operações matemáticas
Exemplos: OP_ADD, OP_SUB, OP_MUL

4. Operações Lógicas:

Operações booleanas
Exemplos: OP_EQUAL, OP_VERIFY, OP_NOT

5. Operações Criptográficas:

Verificações criptográficas
Exemplos: OP_CHECKSIG, OP_HASH160, OP_CHECKMULTISIG

6. Operações de Controle:

Controle de fluxo
Exemplos: OP_IF, OP_ELSE, OP_ENDIF

Opcodes Mais Importantes

OP_DUP:

Duplica item no topo da stack
Útil para verificar chaves públicas

OP_HASH160:

Faz SHA-256 seguido de RIPEMD-160
Usado para hashes de chaves públicas

OP_EQUALVERIFY:

Verifica se dois itens são iguais
Remove itens se forem iguais
Falha se não forem iguais

OP_CHECKSIG:

Verifica assinatura digital
Crucial para segurança
Verifica se assinatura corresponde a chave pública

OP_CHECKMULTISIG:

Verifica múltiplas assinaturas
Usado em multisig
Permite transações que precisam de várias assinaturas

OP_RETURN:

Marca output como não gastável
Usado para dados opcionais
Output é queimado (não pode ser gasto)

Limites e Regras

Limites de scripts:

Tamanho máximo: 10.000 bytes para script completo
Stack size: Máximo 1.000 itens
Tamanho máximo de item: 520 bytes

Regras de execução:

Script deve terminar com valor verdadeiro no topo
Não pode ter loops infinitos
Deve ser determinístico
Não pode acessar dados externos

Stack: Como Scripts Funcionam

O Que É Stack?

Stack (pilha) é estrutura de dados onde scripts operam.

Princípio LIFO:

Last In, First Out
Último item a entrar é primeiro a sair
Como pilha de pratos

Operações básicas:

PUSH: Adiciona item no topo
POP: Remove item do topo
PEEK: Olha item no topo sem remover

Exemplo de Execução na Stack

Script simples: verificar se número é par:

5
OP_DUP
2
OP_MOD
0
OP_EQUAL

Execução passo a passo:

Stack inicial: []

Passo 1: PUSH 5:

Stack: [5]

Passo 2: OP_DUP (duplica 5):

Stack: [5, 5]

Passo 3: PUSH 2:

Stack: [5, 5, 2]

Passo 4: OP_MOD (5 mod 2 = 1):

Stack: [5, 1]

Passo 5: PUSH 0:

Stack: [5, 1, 0]

Passo 6: OP_EQUAL (1 == 0? Não, então 0):

Stack: [5, 0]

Resultado: 0 (falso) no topo = script falha

Execução de Script Completo

Exemplo: Validação P2PKH:

ScriptSig:

<signature>
<publicKey>

ScriptPubKey:

OP_DUP
OP_HASH160
<pubKeyHash>
OP_EQUALVERIFY
OP_CHECKSIG

Execução combinada:

1. Executa ScriptSig:

Stack: [signature, publicKey]

2. Executa OP_DUP:

Stack: [signature, publicKey, publicKey]

3. Executa OP_HASH160:

Stack: [signature, publicKey, hash(publicKey)]

4. Executa PUSH pubKeyHash:

Stack: [signature, publicKey, hash(publicKey), pubKeyHash]

5. Executa OP_EQUALVERIFY:

Verifica se hash(publicKey) == pubKeyHash
Se sim, remove ambos
Se não, script falha

Stack após OP_EQUALVERIFY (se passou):

Stack: [signature, publicKey]

6. Executa OP_CHECKSIG:

Verifica se assinatura corresponde a publicKey
Se sim, coloca 1 (verdadeiro) na stack
Se não, coloca 0 (falso)

Stack final (se passou):

Stack: [1]

Resultado: Script passa (1 = verdadeiro no topo)

Tipos de Scripts Comuns

1. P2PKH (Pay to Public Key Hash)

Estrutura:

ScriptPubKey:

OP_DUP OP_HASH160 <20 bytes: pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG

ScriptSig:

<signature> <publicKey>

Uso: Transações simples para um destinatário

Exemplo simplificado:

ScriptPubKey: OP_DUP OP_HASH160 abc123... OP_EQUALVERIFY OP_CHECKSIG
ScriptSig: sig123... pubkey456...

2. P2SH (Pay to Script Hash)

Estrutura:

ScriptPubKey:

OP_HASH160 <20 bytes: scriptHash> OP_EQUAL

ScriptSig:

<redeemScript> <signatures...>

Uso: Permite scripts mais complexos (multisig, etc.)

Vantagem: Hash é menor que script completo

Exemplo simplificado:

ScriptPubKey: OP_HASH160 hash789... OP_EQUAL
ScriptSig: redeemScript sig1 sig2

3. Multisig

Estrutura:

Redeem Script (dentro de P2SH):

<m> <pubKey1> <pubKey2> ... <pubKeyn> <n> OP_CHECKMULTISIG

O que significa:

Precisa de m assinaturas de n chaves
Exemplo: 2 de 3 (2 assinaturas de 3 chaves)

Uso: Carteiras compartilhadas, segurança adicional

Exemplo simplificado (2 de 3):

2 pubKey1 pubKey2 pubKey3 3 OP_CHECKMULTISIG

4. Timelocks

Estrutura:

OP_CHECKLOCKTIMEVERIFY:

Verifica se tempo/bloco foi atingido
Permite transações com bloqueio temporal

Uso: Transações que só podem ser gastas após data

Exemplo simplificado:

<timestamp>
OP_CHECKLOCKTIMEVERIFY
OP_DROP
OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG

5. OP_RETURN

Estrutura:

ScriptPubKey:

OP_RETURN <dados opcionais>

O que faz:

Marca output como não gastável
Usado para armazenar dados na blockchain
Bitcoin neste output é "queimado"

Uso: Metadados, provas de existência, etc.

Exemplo simplificado:

OP_RETURN Hello World

Exemplos Reais Simplificados

Exemplo 1: Transação P2PKH Simples

Cenário: Alice envia Bitcoin para Bob

Output da transação anterior (Bob vai gastar):

ScriptPubKey: OP_DUP OP_HASH160 <hash da chave pública de Bob> OP_EQUALVERIFY OP_CHECKSIG

Input da transação atual (Bob gasta):

ScriptSig: <assinatura de Bob> <chave pública de Bob>

Validação:

ScriptSig coloca assinatura e chave pública na stack
ScriptPubKey verifica se hash da chave pública corresponde
ScriptPubKey verifica se assinatura é válida
Se ambos passam, transação é válida

Exemplo 2: Transação Multisig (2 de 3)

Cenário: Empresa com 3 diretores, precisa de 2 assinaturas

Redeem Script (dentro de P2SH):

2
<pubKey diretor1>
<pubKey diretor2>
<pubKey diretor3>
3
OP_CHECKMULTISIG

ScriptPubKey (P2SH):

OP_HASH160 <hash do redeem script acima> OP_EQUAL

ScriptSig (quando gastar):

<redeem script>
<assinatura diretor1>
<assinatura diretor2>
<empty> (OP_CHECKMULTISIG tem bug que precisa de elemento extra)

Validação:

Verifica hash do redeem script
Executa redeem script com assinaturas
Verifica se 2 assinaturas de 3 são válidas
Se sim, transação é válida

Exemplo 3: Timelock

Cenário: Bitcoin só pode ser gasto após 1 de janeiro de 2026

ScriptPubKey:

<timestamp: 1735689600> (1 jan 2026)
OP_CHECKLOCKTIMEVERIFY
OP_DROP
OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG

Validação:

Verifica se tempo atual >= timestamp
Se não, script falha
Se sim, continua verificação normal de assinatura

Segurança dos Scripts

Por Que Scripts São Seguros?

Limitações de segurança:

1. Não é Turing-completa:

Não pode fazer loops infinitos
Sempre termina
Não pode travar a rede

2. Determinística:

Sempre produz mesmo resultado
Sem aleatoriedade
Previsível

3. Sem acesso externo:

Não pode acessar internet
Não pode acessar arquivos
Isolado

4. Limites de recursos:

Tamanho máximo de script
Tamanho máximo de stack
Tempo máximo de execução

Ataques Impossíveis

O que scripts NÃO podem fazer:

1. Loops Infinitos:

Sem loops, não pode travar
Sempre termina

2. Acessar Dados Externos:

Não pode fazer requisições HTTP
Não pode acessar blockchain de outras moedas
Isolado

3. Criar Bitcoin:

Não pode criar Bitcoin do nada
Regras econômicas são validadas separadamente

4. Alterar Blockchain:

Scripts só validam
Não modificam blockchain existente

Estrutura de Transações

Onde Scripts Ficam?

Estrutura simplificada de transação:

Transação:
  - Versão
  - Inputs:
      - Hash da transação anterior
      - Índice do output
      - ScriptSig (script de desbloqueio)
      - Sequence
  - Outputs:
      - Valor (em satoshis)
      - ScriptPubKey (script de bloqueio)
  - Locktime

ScriptSig:

Fica em cada input
Fornece dados para gastar UTXO
Removido após validação (SegWit)

ScriptPubKey:

Fica em cada output
Define condições de gasto
Permanece na blockchain

SegWit e Scripts

O que SegWit mudou:

Antes (legacy):

ScriptSig ficava nos inputs
Dados ficavam na blockchain permanentemente
Taxas maiores

Depois (SegWit):

ScriptSig (witness) separado
Não conta no tamanho base da transação
Taxas menores
ScriptPubKey simplificado

Vantagem SegWit:

Transações menores
Taxas menores
Mais espaço para transações no bloco

Perguntas Frequentes

Scripts podem ser alterados depois de criados?

Não. ScriptPubKey fica permanentemente na blockchain e não pode ser alterado. Você só pode gastar output fornecendo ScriptSig correto.

Posso criar meu próprio tipo de script?

Tecnicamente sim, mas você está limitado aos opcodes disponíveis. Scripts customizados precisam seguir regras de consenso.

Scripts são programas completos?

Não. Scripts são muito limitados. Não podem fazer loops, não podem acessar dados externos, e sempre devem terminar. São mais como fórmulas do que programas completos.

Por que scripts não são Turing-completos?

Por segurança. Se fossem Turing-completos, poderiam ter loops infinitos e travar a rede. Limitações garantem que scripts sempre terminem.

Scripts afetam privacidade?

Sim, podem. Scripts complexos podem ser identificados na blockchain. Multisig, timelocks, etc. podem vazar informações sobre como Bitcoin é usado.

Posso ver scripts em transações reais?

Sim. Você pode explorar blockchain e ver ScriptPubKey de qualquer output. ScriptSig geralmente não fica visível (exceto em transações legacy não-SegWit).

Conclusão

Scripts são fundamentais para entender como transações Bitcoin realmente funcionam. Eles definem condições de gasto através de ScriptPubKey e ScriptSig, usando opcodes para executar verificações na stack.

Os pontos principais que você precisa entender são:

ScriptPubKey define condições - Como uma "fechadura" que bloqueia Bitcoin
ScriptSig satisfaz condições - Como uma "chave" que desbloqueia Bitcoin
Opcodes são instruções - Comandos simples que scripts executam
Stack é onde opera - Pilha onde dados são manipulados
Scripts são limitados - Não são Turing-completos por segurança
Tipos comuns existem - P2PKH, P2SH, multisig, timelocks, etc.

Scripts são uma das partes mais interessantes e fundamentais do Bitcoin. Eles permitem flexibilidade sem complexidade excessiva, segurança sem riscos de loops infinitos, e funcionalidades avançadas como multisig e timelocks.

Entender scripts é entender a verdadeira estrutura de transações Bitcoin. Cada transação que você faz usa scripts, mesmo que você não veja diretamente. Scripts definem quem pode gastar cada Bitcoin e como.

Se você quer entender profundamente como Bitcoin funciona, compreender scripts é essencial. É conhecimento técnico avançado que abre portas para entender funcionalidades mais complexas do Bitcoin, como Lightning Network, contratos inteligentes simples, e outras tecnologias construídas sobre scripts.