Bitcoin's blockchain technology relies on a decentralized and secure system for verifying transactions. At the heart of this system lies the concept of transaction scripts, which determine how funds can be spent. These scripts enable complex conditions for transferring ownership of bitcoin, ensuring security and flexibility without relying on centralized authorities.
The Structure of a Bitcoin Transaction
Each block in the Bitcoin blockchain contains one or more transactions. Except for the initial coinbase transaction that rewards miners, every transaction has inputs and outputs. Inputs reference previous transaction outputs, creating a chain of ownership.
- Transaction Inputs (TxIn): These point to unspent transaction outputs (UTXOs) from earlier transactions. Each input includes a reference to the previous transaction's hash and the index of the specific output being spent.
- Transaction Outputs (TxOut): These specify the amount of bitcoin to be transferred and the conditions that must be met to spend them. These conditions are defined by a script called
pkScript.
The entire system operates on the UTXO model. A UTXO is an output from a previous transaction that has not yet been used as an input in a new one. The network tracks all UTXOs to prevent double-spending and verify transaction validity.
How Scripts Secure Ownership
Unlike traditional banking, Bitcoin does not have account names or balances. Instead, ownership is proven cryptographically. When someone sends bitcoin, they don't send it to a name but to a script. This script acts as a locking mechanism, specifying the conditions that must be fulfilled to spend the funds.
A standard script, known as a Pay-to-Public-Key-Hash (P2PKH) script, looks like this:
OP_DUP OP_HASH160 <Public Key Hash> OP_EQUALVERIFY OP_CHECKSIG
This script means: "To spend this output, you must provide a public key that hashes to the specified value and a signature that proves you own the corresponding private key."
👉 Explore advanced scripting methods
Executing a Bitcoin Script
Bitcoin uses a simple, stack-based programming language to execute these scripts. It is intentionally not Turing-complete, meaning it lacks loops and complex flow control to ensure predictability and prevent infinite loops.
The script execution process involves two sets of scripts combined:
- ScriptSig (from the Input): This provides the "solution," typically a signature and a public key.
- ScriptPubKey (from the referenced Output): This defines the "puzzle" or the spending conditions.
These are combined and run through the Bitcoin script engine. The transaction is only valid if the final result on the stack is "true."
Step-by-Step Execution of a P2PKH Script
Let's walk through validating a standard transaction:
- Initial Stack Setup: The ScriptSig (signature and public key) is placed on the stack.
- OP_DUP: Duplicates the top item (the public key) on the stack.
- OP_HASH160: Hashes the duplicated public key.
- Push Public Key Hash: The hash from the ScriptPubKey is pushed onto the stack.
- OP_EQUALVERIFY: Compares the two hashes. If they don't match, execution fails immediately. If they do, both are removed from the stack.
- OP_CHECKSIG: The final step. It uses the remaining public key and signature to verify the transaction's signature. If the cryptographic signature is valid, the result is "true."
This multi-step process cryptographically proves that the spender controls the private key associated with the public key hash without revealing the key itself.
Beyond Basic Transactions: Advanced Scripts
The power of Bitcoin scripting goes beyond simple signatures. It allows for a variety of complex spending conditions, enabling features that resemble smart contracts.
Multisignature Scripts (Multisig)
Multisig scripts require signatures from multiple private keys to spend funds. A common M-of-N script might look like:2 <PubKey1> <PubKey2> <PubKey3> 3 OP_CHECKMULTISIG
This script requires two valid signatures out of the three provided public keys to spend the output. This is ideal for enhancing security for stored funds or for corporate transactions requiring multiple approvals.
Timelocks and OP_CHECKLOCKTIMEVERIFY
This opcode allows a transaction output to be locked until a specified time or block height. Until that condition is met, the funds cannot be spent. This enables escrow services, scheduled payments, and testaments, functioning similarly to a time-delayed safe.
Unusual and Puzzle Scripts
Some scripts create cryptographic puzzles. For example, a script might require providing data that hashes to a specific value (OP_HASH256 ... OP_EQUAL). Spending such an output requires finding the preimage data that solves the puzzle, which can be computationally difficult.
These advanced scripts demonstrate that Bitcoin is more than a simple payment network. It is a platform for programmable value transfer, where ownership can be conditional and complex agreements can be enforced automatically and trustlessly.
👉 View real-time tools for blockchain analysis
Frequently Asked Questions
What is a Bitcoin transaction script?
A Bitcoin transaction script is a set of instructions written in Bitcoin's scripting language that defines the conditions under which a transaction output can be spent. It acts as a digital lock, and the spender must provide the correct "key" in the form of data and signatures that, when combined with the script, execute successfully.
How does a script prove ownership of bitcoin?
Ownership is proven by providing the solution to the cryptographic puzzle in the script. For the most common script type (P2PKH), this involves providing a digital signature and a public key. The signature proves control of the private key, and the public key must hash to the value specified in the original output's script.
What does it mean that Bitcoin script is not Turing-complete?
It means the language is intentionally limited. It lacks loops and complex conditional branching. This ensures that every script will terminate in a predictable amount of time, preventing denial-of-service attacks where a malicious script could run forever and halt the network.
What is a multisignature address?
A multisignature address is one associated with a script that requires more than one private key to authorize a transaction. For example, a 2-of-3 multisig address requires any two of the three designated keys to sign. This enhances security by distributing control and providing redundancy.
Can Bitcoin scripts be used for smart contracts?
Yes, in a fundamental sense. While not as flexible as the smart contracts on platforms like Ethereum, Bitcoin scripts are a form of smart contract. They allow for the creation of programmable money that can be spent only when certain predefined conditions are met, such as multiple signatures or time locks.
Are transaction scripts visible on the blockchain?
Yes, every transaction and its associated scripts are recorded publicly on the blockchain. Anyone can inspect the ScriptPubKey of any UTXO and the ScriptSig used to spend it, allowing for complete transparency and verifiability of the rules governing every transaction.