translate bitcoin script section

Author: KaKeimei

docs/contract/bitcoin-scripts/dual-stack-model.md

@@ -1,4 +1,72 @@
 ---
 sidebar_position: 1
 ---
-# Dual Stack model
+
+# Dual Stack Model
+
+Bitcoin script execution involves a stack-based programming language used to verify transactions on the Bitcoin network.
+Here is an overview of the Bitcoin script execution stack:
+
+## Script Composition
+
+- **ScriptPubKey**: This is the locking script attached to the output, specifying the conditions that must be met to
+  spend the output.
+- **ScriptSig**: This is the unlocking script included in the input, providing the data required to meet the conditions
+  in ScriptPubKey.
+
+## Execution Stack
+
+The execution stack is used to process and evaluate Bitcoin scripts. Here’s how it works:
+
+1. **Push Operations**: Push data and commands (opcodes) onto the stack.
+    - Example: `OP_DUP` duplicates the top item on the stack.
+    - Example: `OP_HASH160` performs a RIPEMD-160 hash after SHA-256.
+
+2. **Script Execution**:
+    - ScriptSig and ScriptPubKey are concatenated and executed sequentially.
+    - First, ScriptSig is executed, pushing its data onto the stack.
+    - Then, ScriptPubKey is executed, using the data left on the stack by ScriptSig.
+
+3. **Stack Operations**:
+    - Various operations modify the stack. For example:
+        - `OP_ADD` pops two items from the stack, adds them, and pushes the result back onto the stack.
+        - `OP_EQUALVERIFY` checks if the top two items are equal and removes them if they are.
+
+4. **Conditionals and Control Structures**:
+    - Conditional operations like `OP_IF`, `OP_ELSE`, and `OP_ENDIF` allow for more complex scripts by enabling
+      conditional execution paths.
+
+5. **Validation**:
+    - After executing all commands, the stack should be in a specific state for the transaction to be valid.
+    - Typically, the final stack state should have a single `TRUE` value, indicating successful script execution.
+
+## Example Transaction Execution
+
+1. **ScriptSig**: `<signature> <public key>`
+    - Pushes the signature and public key onto the stack.
+
+2. **ScriptPubKey**: `OP_DUP OP_HASH160 <PubKeyHash> OP_EQUALVERIFY OP_CHECKSIG`
+    - `OP_DUP`: Duplicates the public key.
+    - `OP_HASH160`: Hashes the duplicated public key.
+    - `<PubKeyHash>`: Pushes the expected public key hash.
+    - `OP_EQUALVERIFY`: Verifies that the public key hash matches the expected hash.
+    - `OP_CHECKSIG`: Verifies the signature using the public key.
+
+## Stack Execution Flow
+
+- **Initial Stack (after executing ScriptSig)**:
+    - Stack: `[signature, public key]`
+
+- **Executing ScriptPubKey**:
+    - `OP_DUP`: `[signature, public key, public key]`
+    - `OP_HASH160`: `[signature, public key, public key hash]`
+    - `<PubKeyHash>`: `[signature, public key, public key hash, expected public key hash]`
+    - `OP_EQUALVERIFY`: Verifies and removes the public key hash and expected public key hash if they match.
+    - `OP_CHECKSIG`: Verifies the signature using the public key.
+
+- **Final Stack**:
+    - If valid: `[TRUE]`
+    - If invalid: `[FALSE]` or script failure, resulting in the transaction being rejected.
+
+Understanding the Bitcoin script execution stack is crucial for developers working on Bitcoin transactions as it ensures
+the correct and secure validation of transaction conditions.

docs/contract/bitcoin-scripts/opcode.md

@@ -1,4 +1,90 @@
 ---
 sidebar_position: 5
 ---
+
 # P2MS
+
+Introduction to P2MS output.
+
+## What is P2MS Output?
+
+P2MS (Pay-to-MultiSig, or "Pay to Multiple Signatures") is a type of transaction output in the Bitcoin network that
+allows multiple signers to jointly manage a fund. This mechanism is often used to enhance security and fault tolerance,
+such as in corporate accounts managed by multiple parties. A P2MS output can specify how many signers' signatures are
+required to spend the funds, providing a flexible multi-signature solution.
+
+## Structure of P2MS Output
+
+The script for a P2MS output is called the locking script (scriptPubKey), and its typical structure is as follows:
+
+```
+m <public key 1> <public key 2> ... <public key n> n OP_CHECKMULTISIG
+```
+
+In this script:
+
+- `m`: Indicates the minimum number of signatures required to spend the funds.
+- `<public key 1> <public key 2> ... <public key n>`: These are the public keys of the participants in the
+  multi-signature scheme.
+- `n`: Indicates the total number of public keys involved.
+- `OP_CHECKMULTISIG`: This opcode verifies if the provided signatures meet the required minimum number of signatures.
+
+To better understand the P2MS output, let's break down its script:
+
+1. `m`: Specifies the required minimum number of signatures.
+2. `<public key 1> <public key 2> ... <public key n>`: Provides multiple public keys.
+3. `n`: Specifies the total number of public keys.
+4. `OP_CHECKMULTISIG`: Verifies if the signatures meet the `m` valid signatures requirement.
+
+## Characteristics of P2MS Output
+
+1. **Increased Security**: P2MS output allows multiple signers to manage a fund together, reducing the risk of a single
+   point of failure. If one signer's private key is compromised, the attacker still needs the private keys of the other
+   signers to spend the funds.
+2. **Flexibility**: P2MS output can set the signature threshold (`m`) and the total number of signers (`n`) as needed.
+   For example, it can be set to 3-of-5 signatures, meaning any 3 out of 5 public keys are needed to spend the funds.
+3. **Complexity**: Compared to P2PKH output, the script for P2MS output is more complex, requiring more computation and
+   verification steps. While it increases security, it also adds complexity and transaction size in bytes.
+
+## Use Cases for P2MS Output
+
+P2MS output is very useful in scenarios that require joint management or enhanced security. Here are some typical use
+cases:
+
+1. **Corporate Fund Management**: Companies can use P2MS output to set up multi-signature accounts, ensuring that
+   multiple authorized signers are required to spend company funds.
+2. **Joint Investments**: Multiple investors can use P2MS output to jointly manage an investment fund, only being able
+   to spend the funds with consensus.
+3. **Family Financial Security**: Family members can set up multi-signature accounts to ensure the secure management of
+   family funds.
+
+## Example of a P2MS Transaction
+
+Here is a simplified example of a P2MS transaction:
+
+- Locking Script (scriptPubKey):
+  ```
+  2 <public key 1> <public key 2> <public key 3> 3 OP_CHECKMULTISIG
+  ```
+
+- Unlocking Script (scriptSig):
+  ```
+  OP_0 <signature 1> <signature 2>
+  ```
+
+When spending this Bitcoin, the unlocking script must be provided, containing the signatures that meet the minimum
+number required. In this example, at least two signatures are needed to spend the funds. The verification process is as
+follows:
+
+1. `OP_0`: Due to a small bug in the Bitcoin script, an invalid opcode (usually `OP_0`) needs to be placed on top of the
+   stack.
+2. `<signature 1> <signature 2>`: Provide two valid signatures.
+3. `OP_CHECKMULTISIG`: Takes signatures and public keys from the stack, verifying if at least two signatures are valid.
+
+## Conclusion
+
+P2MS output, as a transaction type that allows multi-signature verification, provides enhanced security and flexibility
+in the Bitcoin network. It is suitable for scenarios requiring joint management, such as corporate fund management,
+joint investments, and family financial security. Although its script structure is relatively complex, the use of P2MS
+output can significantly increase the security of fund management. Understanding P2MS output is important for mastering
+advanced uses of Bitcoin and multi-signature mechanisms.

docs/contract/bitcoin-scripts/p2ms.md

@@ -1,4 +1,80 @@
 ---
 sidebar_position: 3
 ---
+
 # P2PK
+
+Introduction to P2PK Output.
+
+## What is P2PK Output?
+
+P2PK (Pay-to-PubKey) is an earlier type of output in the Bitcoin network used to pay directly to a specific public key.
+Although it is relatively rare in modern Bitcoin transactions, understanding P2PK is important for grasping Bitcoin
+transactions and script systems.
+
+### Structure of P2PK Output
+
+The structure of a P2PK output is relatively simple, directly containing the recipient's public key. A typical P2PK
+script is as follows:
+
+```
+<public key> OP_CHECKSIG
+```
+
+In this script:
+
+- `<public key>`: This is the recipient's public key.
+- `OP_CHECKSIG`: This is an opcode used to verify the signature.
+
+To better understand the P2PK output, let's break down its script:
+
+1. `<public key>`: This is a compressed or uncompressed Bitcoin public key.
+2. `OP_CHECKSIG`: This is an opcode that takes a signature and a public key from the stack and verifies if the signature
+   is valid using the public key.
+
+### Characteristics of P2PK Output
+
+1. **Simplicity**: The P2PK output structure is simple, containing only a public key and an opcode. This simplicity made
+   it widely used in early versions of Bitcoin.
+2. **Direct Payment to Public Key**: Unlike P2PKH (Pay-to-PubKeyHash) outputs, which use a public key hash to find the
+   public key, P2PK outputs use the public key directly. This simplifies the verification process but introduces some
+   privacy and security issues.
+3. **Privacy Issues**: Since P2PK outputs directly contain the public key, anyone can see the recipient's public key.
+   This could lead to privacy issues as the public key can be linked to the user's other transactions or identity
+   through certain techniques.
+4. **Security Issues**: Assuming the threat of quantum computers to public key cryptography, directly exposing the
+   public key might reduce security since quantum computers could potentially derive the private key from the public
+   key.
+
+### Use Cases for P2PK Output
+
+Although P2PK outputs are uncommon in modern Bitcoin transactions, they played a significant role in Bitcoin's early
+development. Here are some possible use cases:
+
+1. **Miner Rewards**: The Bitcoin genesis block and some early blocks used P2PK outputs for miner rewards.
+2. **Simple Peer-to-Peer Payments**: In Bitcoin's early days, users might have used P2PK outputs for simple peer-to-peer
+   payments.
+
+### Modern Alternatives
+
+Due to the privacy and security issues of P2PK outputs, modern Bitcoin transactions more commonly use P2PKH (
+Pay-to-PubKeyHash) outputs and P2SH (Pay-to-ScriptHash) outputs.
+
+- **P2PKH**: P2PKH outputs use public key hashes instead of direct public keys, providing some privacy and security
+  protection. A typical P2PKH script is as follows:
+  ```
+  OP_DUP OP_HASH160 <public key hash> OP_EQUALVERIFY OP_CHECKSIG
+  ```
+
+- **P2SH**: P2SH outputs allow more complex scripts, supporting multi-signature and other advanced functions. A typical
+  P2SH script is as follows:
+  ```
+  OP_HASH160 <script hash> OP_EQUAL
+  ```
+
+### Conclusion
+
+As an early type of transaction output in the Bitcoin network, P2PK outputs, although less common today, provide an
+important foundation for understanding Bitcoin transactions and script systems. As the Bitcoin network has evolved, more
+complex and secure output types like P2PKH and P2SH have gradually replaced P2PK outputs, but understanding P2PK outputs
+is still essential for a comprehensive grasp of Bitcoin technology.

docs/contract/bitcoin-scripts/p2pk.md

@@ -1,4 +1,87 @@
 ---
 sidebar_position: 4
 ---
+
 # P2PKH
+
+Introduction to P2PKH Output.
+
+## What is P2PKH Output?
+
+P2PKH (Pay-to-PubKeyHash) is the most common type of transaction output in the Bitcoin network. It provides better
+privacy and security compared to the earlier P2PK (Pay-to-PubKey) output. P2PKH allows Bitcoin to be paid to a public
+key hash rather than directly to a public key, thereby protecting the recipient's privacy to some extent.
+
+## Structure of P2PKH Output
+
+The script for a P2PKH output is called the locking script (scriptPubKey), and its typical structure is as follows:
+
+```
+OP_DUP OP_HASH160 <public key hash> OP_EQUALVERIFY OP_CHECKSIG
+```
+
+To understand this script, let's break down its components:
+
+1. **OP_DUP**: Duplicates the top stack item.
+2. **OP_HASH160**: Performs RIPEMD-160 hashing on the top stack item (after SHA-256 hashing).
+3. **\<public key hash>**: The recipient's public key hash.
+4. **OP_EQUALVERIFY**: Verifies that the two top stack items are equal; if not, the script fails.
+5. **OP_CHECKSIG**: Checks if the signature is valid.
+
+In a P2PKH transaction, the sender's unlocking script (scriptSig) needs to provide:
+
+1. Signature: Proves the sender's authorization of the transaction.
+2. Public Key: Matches the public key hash in the locking script.
+
+## Characteristics of P2PKH Output
+
+1. **Enhanced Privacy**: P2PKH outputs include only the hash of the public key, not the public key itself. This makes
+   tracking the recipient's public key more difficult, thus enhancing privacy.
+2. **Improved Security**: Transactions that directly include public keys are more susceptible to potential quantum
+   computing attacks. P2PKH outputs provide an additional layer of security by using the public key hash. Cracking a
+   hash is harder than cracking a public key for a quantum computer.
+3. **Widespread Use**: P2PKH outputs are the most common type of output in Bitcoin transactions, widely used in various
+   transaction scenarios.
+4. **Support for Lightweight Clients**: P2PKH outputs enable lightweight clients (such as SPV wallets) to verify
+   transactions more efficiently, as these clients only need to check the public key hash instead of processing the full
+   public key.
+
+## Use Cases for P2PKH Output
+
+P2PKH outputs are widely used in the Bitcoin network, covering almost all everyday transactions for regular users. Here
+are some typical use cases:
+
+1. **Personal Wallet Transactions**: Most Bitcoin wallets default to using P2PKH outputs to receive Bitcoin.
+2. **Merchant Payments**: Many online merchants and service providers use P2PKH addresses to receive payments from
+   customers.
+3. **Exchange Transfers**: When users deposit and withdraw Bitcoin on exchanges, they typically use P2PKH outputs.
+
+## Example of a P2PKH Transaction
+
+Here is a simplified example of a P2PKH transaction:
+
+- Locking Script (scriptPubKey):
+  ```
+  OP_DUP OP_HASH160 <public key hash> OP_EQUALVERIFY OP_CHECKSIG
+  ```
+
+- Unlocking Script (scriptSig):
+  ```
+  <signature> <public key>
+  ```
+
+When the recipient wants to spend this Bitcoin, they need to provide the unlocking script, which includes a valid
+signature and the public key that matches the public key hash. The verification process is as follows:
+
+1. `OP_DUP`: Duplicates the public key in the unlocking script.
+2. `OP_HASH160`: Hashes the public key to generate the public key hash.
+3. `OP_EQUALVERIFY`: Verifies that the calculated public key hash matches the one in the locking script.
+4. `OP_CHECKSIG`: Uses the provided public key to verify the signature's validity.
+
+## Conclusion
+
+As the most common type of transaction output in the Bitcoin network, P2PKH outputs provide enhanced privacy and
+security. Their structure makes Bitcoin payments more secure and private, suitable for various transaction scenarios.
+From personal wallets to merchant payments, P2PKH outputs play a crucial role in the Bitcoin ecosystem, driving the
+widespread adoption and usage of Bitcoin. Understanding P2PKH outputs is essential for comprehending Bitcoin transaction
+mechanisms and improving Bitcoin usage security.