Previous transaction output: OP_DUP OP_HASH160 <Alice's Public Key Hash> OP_EQUALVERIFY OP_CHECKSIG
Current transaction input: <Alice's Signature> <Alice's Public Key>

Previous transaction output: OP_2 <PubKey1> <PubKey2> <PubKey3> OP_3 OP_CHECKMULTISIG (2-of-3 multisig)
Current transaction input: OP_0 <Signature1> <Signature2> <Redeem Script>

Someone previously sent Alice a safe labeled: "Only Alice's key can open this"
Now Alice wants to use the money inside — she just needs her key (private key signature)

Someone previously sent a company a safe labeled: "Requires any 2 of the CEO, CFO, or CTO's keys to open"
Now the company wants to use the money — 2 people must use their keys simultaneously (2 private key signatures)

javascript
// Simplified version of Bitcoin's multisig verification logic
bool CheckMultiSig() {
    //... signature verification logic ...

    // Bug: pops one extra element
    stack.pop();  // This line shouldn't exist

    // Verification result
    return isValid;
}

Actual required stack:
[OP_0] [Signature2] [Signature1] [PubKey1] [PubKey2] [PubKey3] [2] [3] [OP_CHECKMULTISIG]
 ^
 This OP_0 is the "shim" that gets consumed by the buggy extra pop

json
{
  "txid": "b2c3d4e5f6a7...(truncated)",
  "vout": 1,
  "scriptSig": {
    "asm": "OP_0 3045022100a1b2c3...(Signature 1) 3044022067c8d9...(Signature 2)",
    "hex": "00483045022100a1b2c3...473044022067c8d9..."
  },
  "sequence": 4294967295
}

json
{
  "value": 0.05000000,
  "n": 1,
  "scriptPubKey": {
    "asm": "OP_HASH160 1234567890abcdef...(20-byte script hash) OP_EQUAL",
    "hex": "a9141234567890abcdef...87",
    "type": "scripthash",
    "address": "3AnNyxwqnDUP7r3jKFaLWcqwYBdXjTPoBe"
  }
}

Typical configuration: 3-of-5 multisig
Participants:
- CEO (primary decision maker)
- CFO (finance lead)
- CTO (technology lead)
- Board Member A
- Board Member B

Use cases:
- Large fund transfers require 3-person approval
- Prevents single points of failure
- Enhanced security

Typical configuration: 2-of-3 multisig
Participants:
- User (fund owner)
- Escrow service provider
- Third-party arbitrator

Use cases:
- User retains partial control
- Escrow provider offers professional management
- Third party intervenes in disputes

Typical configuration: 2-of-2 multisig
Participants:
- Spouse A
- Spouse B

Use cases:
- Joint management of family funds
- Both parties must agree to spend
- Enhanced family financial security

Typical configuration: 2-of-3 multisig
Participants:
- Primary wallet
- Backup Wallet A
- Backup Wallet B

Use cases:
- Prevents single points of failure
- Multiple backup protection
- Disaster recovery

python
import requests
import json

def bitcoin_rpc(method, params=[]):
    url = "http://localhost:8332"
    headers = {'content-type': 'application/json'}

    payload = {
        "method": method,
        "params": params,
        "jsonrpc": "2.0",
        "id": 0,
    }

    response = requests.post(url, data=json.dumps(payload), headers=headers, auth=('user', 'password'))
    return response.json()

def create_multisig_address():
    # 1. Generate public keys (example)
    pubkeys = [
        "03a1b2c3d4e5f6...",  # Public Key 1
        "03b1c2d3e4f5a6...",  # Public Key 2
        "03c1d2e3f4a5b6..."   # Public Key 3
    ]

    # 2. Create a 2-of-3 multisig address
    result = bitcoin_rpc("createmultisig", [2, pubkeys])

    print(f"Multisig Address: {result['result']['address']}")
    print(f"Redeem Script: {result['result']['redeemScript']}")

    return result['result']

# Execute multisig address creation
multisig_info = create_multisig_address()

python
def sign_multisig_transaction(raw_tx, private_keys, redeem_script):
    """
    Sign a multisig transaction
    """

    # 1. Sign with the first private key
    signed_tx1 = bitcoin_rpc("signrawtransaction", [raw_tx, [{"txid": "prev_txid", "vout": 0, "scriptPubKey": "script", "redeemScript": redeem_script}], [private_keys[0]]])

    # 2. Sign with the second private key
    signed_tx2 = bitcoin_rpc("signrawtransaction", [signed_tx1['result']['hex'], [{"txid": "prev_txid", "vout": 0, "scriptPubKey": "script", "redeemScript": redeem_script}], [private_keys[1]]])

    return signed_tx2['result']['hex']

def broadcast_multisig_transaction(signed_tx):
    """
    Broadcast a multisig transaction
    """

    result = bitcoin_rpc("sendrawtransaction", [signed_tx])
    return result['result']

python
class MultiSigWallet:
    def __init__(self, pubkeys, required_signatures):
        self.pubkeys = pubkeys
        self.required_signatures = required_signatures
        self.address = None
        self.redeem_script = None

    def create_wallet(self):
        """Create a multisig wallet"""
        result = bitcoin_rpc("createmultisig", [self.required_signatures, self.pubkeys])
        self.address = result['result']['address']
        self.redeem_script = result['result']['redeemScript']
        return self.address

    def create_transaction(self, outputs):
        """Create a multisig transaction"""
        inputs = [{"txid": "previous_utxo", "vout": 0}]
        raw_tx = bitcoin_rpc("createrawtransaction", [inputs, outputs])
        return raw_tx['result']

    def sign_transaction(self, raw_tx, private_key):
        """Sign a transaction"""
        # Implement signing logic
        pass

    def broadcast_transaction(self, signed_tx):
        """Broadcast a transaction"""
        return bitcoin_rpc("sendrawtransaction", [signed_tx])

# Usage example
pubkeys = ["pubkey1", "pubkey2", "pubkey3"]
wallet = MultiSigWallet(pubkeys, 2)
address = wallet.create_wallet()
print(f"Multisig Address: {address}")

Security comparison:

Single-signature risks:
- Private key lost -> Funds permanently lost
- Private key leaked -> Funds stolen

2-of-3 multisig security:
- 1 key lost -> Can still use the other 2
- 1 key leaked -> Attacker still needs another key
- Attacker must obtain 2 keys simultaneously to steal funds

Fee comparison:
- Single-signature transaction: ~225 bytes
- 2-of-3 multisig: ~400 bytes
- 3-of-5 multisig: ~500 bytes

Reasons for higher fees:
- More signature data needed
- Redeem script takes up space
- More complex verification logic