Bitcoin Improvement Proposals

https://github.com/bitcoin/bips
Admin
A repository serving as a publication medium and archive for Bitcoin Improvement Proposals,...
Tokens:126,942
Snippets:824
Trust Score:8.2
Update:1 month ago
Show doc for...
Tokens:
Raw
### Multiple Authors Header Example

Source: https://github.com/bitcoin/bips/blob/master/bip-0003.md

Example of the Authors header with multiple authors, each on a separate line.

```text
Authors: Random J. User <address@dom.ain>
         Anata Sample <anata@domain.example>

```

--------------------------------

### Run typos check

Source: https://github.com/bitcoin/bips/blob/master/CONTRIBUTING.md

Install the 'typos' tool and run it in the root directory to check for common typos locally, matching the CI check.

```bash
typos
```

--------------------------------

### Authors Header Format Example

Source: https://github.com/bitcoin/bips/blob/master/bip-0003.md

Format for the Authors header value. The example shows a single author format. Multiple authors are placed on separate lines.

```text
Random J. User <address@dom.ain>

```

--------------------------------

### Start RelayDandelionTransaction in net_processing.cpp

Source: https://github.com/bitcoin/bips/blob/master/bip-0156/dandelion-reference-documentation.pdf

Starts the Dandelion relay function with a fast random context for fluff decisions.

```cpp
src/net_processing.cpp
static void RelayDandelionTransaction(
const CTransaction& tx, CConnman* connman, CNode* pfrom)
{
FastRandomContext rng;

```

--------------------------------

### Committing to more than 2 elements using OP_PAIRCOMMIT

Source: https://github.com/bitcoin/bips/blob/master/bip-0442.md

Pseudo-code witness stack demonstrating how OP_PAIRCOMMIT can commit to three elements (a, b, c). The example shows the witness stack and the operations needed to verify that the stack matches a provided pair-commitment hash.

```perl
# Commit to three elements: a, b, c
# pc-hash = PC(a, PC(b, c))

# Witness: <a> <b> <c>
OP_PAIRCOMMIT                          # <a>, PC(b, c)
OP_PAIRCOMMIT                          # PC(a, PC(b, c))
<pc-hash>                              # PC(a, PC(b, c)), <pc-hash>
OP_EQUALVERIFY                         #
# ...
```

--------------------------------

### Lightning Symmetry example channel script (pseudo-code)

Source: https://github.com/bitcoin/bips/blob/master/bip-0442.md

Pseudo-code for a channel script in Lightning Symmetry. The script forces both parties to include a settlement transaction hash and a state hash in the witness via OP_PAIRCOMMIT, then checks the signature and a locktime.

```perl
# S:                                   500000000
# internal-key:                        BIP-327 aggregate key of channel participants
# state-n-hash:                        { nLockTime(S+n), out(contract, amount(A)+amount(B)) }
# settlement-n-hash:                   { nSequence(2w), out(A, amount(A)), out(B, amount(B)) }
# state-n-recovery-data:               { settlement-n-hash or state-n-balance }
```

```perl
# Witness: <sig> <state-n-recovery-data> <state-n-hash>
OP_CHECKTEMPLATEVERIFY                 # <sig>, <state-n-recovery-data>, <state-n-hash>
OP_PAIRCOMMIT                          # <sig>, PC(state-n-recovery-data, state-n-hash)
OP_INTERNALKEY                         # <sig>, PC(state-n-recovery-data, state-n-hash), <internal-key>
OP_CHECKSIGFROMSTACK                   # <1>
<S+1>                                  # <1>, <S+1>
OP_CHECKLOCKTIMEVERIFY                 # <1>, <S+1>
OP_DROP                                # <1>
```

--------------------------------

### Input x(2G), t = 3

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector with input x(2G) and tweak t = 3. The expected result is the public key for 5G.

```text
  pubkey32    =  c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5
  tweak32     =  0000000000000000000000000000000000000000000000000000000000000003
  expect      =  2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4

  script      =  <0000000000000000000000000000000000000000000000000000000000000003> <c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5> OP_TWEAKADD <2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4> OP_EQUAL
```

--------------------------------

### Input x(7G), t = 9

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector with input x(7G) and tweak t = 9. The expected result is the public key for 16G.

```text
  pubkey32    =  5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc
  tweak32     =  0000000000000000000000000000000000000000000000000000000000000009
  expect      =  e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a

  script      =  <0000000000000000000000000000000000000000000000000000000000000009> <5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc> OP_TWEAKADD <e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a> OP_EQUAL
```

--------------------------------

### Minimal script using pubkeys

Source: https://github.com/bitcoin/bips/wiki/Comments:BIP-0199

A script that uses pubkeys directly instead of pubkey hashes to minimize witness space. It uses a hash operation to compare a digest, then conditionally checks the seller or buyer pubkey.

```script
[HASHOP] <digest> OP_EQUAL
OP_IF
    <seller pubkey>            
OP_ELSE
    <num> [TIMEOUTOP] OP_DROP <buyer pubkey>
OP_ENDIF
OP_CHECKSIG
```

--------------------------------

### Run BIP-375 validation tests

Source: https://github.com/bitcoin/bips/blob/master/bip-0375/README.md

Commands to run the test suite with various verbosity levels and a custom test vector file. Use -v for detailed validation status, -vv for failure reasons, and -f to specify a custom vector file.

```bash
python test_runner.py                    # Run all tests
python test_runner.py -v                 # Verbose mode with detailed validation status
python test_runner.py -vv                # More verbose with validation check failure reason

python test_runner.py -f vectors.json    # Use custom test vector file
```

--------------------------------

### OP_TWEAKADD stack semantics

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Shows the stack semantics of OP_TWEAKADD: it consumes a 32-byte tweak and a 32-byte x-only public key, and pushes the resulting 32-byte x-only public key.

```text
... [tweak32] [pubkey32] OP_TWEAKADD  -> ... [pubkey32_out]
```

--------------------------------

### Serialized staletip payload (946 bytes) for signet stale branch

Source: https://github.com/bitcoin/bips/blob/master/bip-0332.md

Hex-encoded serialized staletip message payload from a 19-block stale branch on signet. This vector has have_block set to false, so it is not an example of a relayable Signet staletip message. The payload contains a fork point, vector length, 19 compressed headers, and a have_block flag.

```hex
1c7e50802a59c42d780861d2c154a87cb02ff42305a933af2ede2f60120000001300000020
67aa2937b235e209f1ad40f37b17dcad8ca02d1fb9cf4c4928902eab3ff853a6cda16e6916
58151d81ad7b0400000020721ab6f36042842bab4583f98e15181b646c47c7b9dfb07a204c
4e5152e54e97fda46e691658151dd2dcec1800000020ddc6b628101b404f78d446591a623e
12bb7e7cd2ae1593d0cc6ef082e19fa81014a66e691658151d46070e10000000208be5b960
7b20ac0163b885881aa6018ef60a5637b93a9cd85981515a169a31c36aab6e691658151de4
e10600000000206c974ef806b2e6a21cc9a53fedcbd5d5e203b4929a1bd7c5859ec77d0a75
5c1d64ae6e691658151d2a2e130e0000002039505fa2ee91f5e5b2540b4a9a7f02ed58d79f
c387412cf2520a39ee16bf435f6eb16e691658151db29c830a00000020411bce69cda2b239
c74faea1f0cfaceabd90377114dc0ace14e2a58858cd4f9a91b46e691658151d4c2d3f0500
00002096464a2ec42fea8419a5c6adcc41ca7dc3f53461cd0afc880f76498aa8eedbf993b5
6e691658151d5e99700b00000020c3cad611ee3c7bffec3f80fc83f68192ca0a86e8c89050
f8353480310d080caf08b76e691658151dbc61a6150000002079e36b5a06bb5a524a2f5bad
6725451613c354cbf64f9a0283f77fe90782d59fcbba6e691658151d6c669300000000204c
69fd467818994e7ff885181e7451d23869a7fd19447dad7a95398077ed7774dcba6e691658
151dc9c7ff02000000208ea9a871b12cd45226ab6df280ec46b8c9ca196b98dc8adc27718c
ab333e19a50abc6e691658151df6bae902000000209c182979424a5c85d55d5bddbf3b9421
b01b7810edf95ad2529552dd2eec80848ebd6e691658151d439e5c0000000020cfb9f6d164
3613dfdd23a6e1eabadac38c392f985f5dc05b00ef682c428922c96cbe6e691658151d278b
4d1400000020eea983b8d64947368de4f7626531a3134d18f20a8d87462ba011a4f56a53b6
ac4fbf6e691658151ddae8640800000020140bc70b1a3282fbebf9d48ff40a9b73ab7c76ad
522799cee73315e9c21aab50dcc06e691658151dedaae90f000000209b91a056fe089429f2
ba4298e764acb4177249ce7d68e6883836f70d1d9218b355c16e691658151d28a432060000
0020b26e80c6a12cc4595556d2318fda564ced5d2a526c7b77f57a9897a56c10539056c16e
691658151dc64fb50000000020369d36495749c96d36260d839abfa703a611aad7b3016342
ef05d0412f42221e6ac56e691658151d8f8bfb0f00
```

--------------------------------

### Dandelion route selection and local push in src/net.cpp

Source: https://github.com/bitcoin/bips/blob/master/bip-0156/dandelion-reference-documentation.pdf

Implementation in src/net.cpp for Dandelion route selection and local destination inventory pushing. If the inbound peer already has a route, return it; otherwise select a new destination and record it. The local Dandelion destination is a private CNode pointer held by CConnman, and PushInventory is called on it when the destination is set.

```cpp
CNode* CConnman::getDandelionDestination(CNode* pfrom) {
for (auto const& e : mDandelionRoutes) {
if (pfrom==e.first) {
return e.second;
CNode* newPto = SelectFromDandelionDestinations();
if (newPto!=nullptr) {
mDandelionRoutes.insert(std::make_pair(pfrom, newPto));
LogPrint(BCLog::DANDELION,"Added Dandelion route:\n%s",...);
return newPto;
bool CConnman::localDandelionDestinationPushInventory(const CInv& inv
if(isLocalDandelionDestinationSet()) {
localDandelionDestination->PushInventory(inv);
return true;
} else if (setLocalDandelionDestination()) {
localDandelionDestination->PushInventory(inv);
return true;
} else {
return false;
```

--------------------------------

### CConnman Dandelion shuffle thread and route shuffling

Source: https://github.com/bitcoin/bips/blob/master/bip-0156/dandelion-reference-documentation.pdf

Implements the periodic Dandelion route shuffle in Bitcoin Core's CConnman. The Start method launches a dedicated thread that calls ThreadDandelionShuffle, which schedules shuffles using PoissonNextSend and DANDELION_SHUFFLE_INTERVAL. The Stop method joins the thread. DandelionShuffle clears existing routes and destinations, repopulates the destination vector up to DANDELION_MAX_DESTINATIONS or the number of outbound peers, and assigns each inbound peer a random destination.

```cpp
void CConnman::ThreadDandelionShuffle() {
int64_t nNextDandelionShuffle=PoissonNextSend(GetTimeMicros(),
DANDELION_SHUFFLE_INTERVAL);
while (!interruptNet) {
nCurrTime = GetTimeMicros();
if (nCurrTime > nNextDandelionShuffle) {
DandelionShuffle();
nNextDandelionShuffle = PoissonNextSend(nCurrTime,
DANDELION_SHUFFLE_INTERVAL);
if (!interruptNet.sleep_for(std::chrono::milliseconds(
(nNextDandelionShuffle-nCurrTime)/1000))) { return; }
}
}
}
bool CConnman::Start(...) {...
threadDandelionShuffle=std::thread(&TraceThread
<std::function<void()> >,"dandelion",std::function<void()>(
std::bind(&CConnman::ThreadDandelionShuffle, this)));...
}
void CConnman::Stop() {...
if (threadDandelionShuffle.joinable()) {
threadDandelionShuffle.join();
}...
}
void CConnman::DandelionShuffle() {
LogPrint(BCLog::DANDELION,"Before Dandelion shuffle:\n%s",...);
{ LOCK(cs_vNodes);
for (auto iter=mDandelionRoutes.begin();
iter!=mDandelionRoutes.end();) {
iter = mDandelionRoutes.erase(iter);
}
if (localDandelionDestination!=nullptr) {
localDandelionDestination = nullptr;
} vDandelionDestination.clear();
while (
vDandelionDestination.size()<DANDELION_MAX_DESTINATIONS &&
vDandelionDestination.size()<vDandelionOutbound.size()) {
std::vector<CNode*> candidateDestinations;
for (auto iteri=vDandelionOutbound.begin();
iteri!=vDandelionOutbound.end();) {
bool eligibleCandidate = true;
for (auto iterj=vDandelionDestination.begin();
iterj!=vDandelionDestination.end();) {
if (*iteri==*iterj) {
eligibleCandidate = false;
iterj = vDandelionDestination.end();
} else { iterj++; }
}
if (eligibleCandidate) {
candidateDestinations.push_back(*iteri);
} iteri++;
} FastRandomContext rng;
if (candidateDestinations.size()>0) {
vDandelionDestination.push_back(candidateDestinations.at(
rng.randrange(candidateDestinations.size())));
} else { break; }
}
for (auto pnode : vDandelionInbound) {
CNode* pto = SelectFromDandelionDestinations();
if (pto != nullptr) {
mDandelionRoutes.insert(std::make_pair(pnode, pto));
}
}
localDandelionDestination=SelectFromDandelionDestinations();
}LogPrint(BCLog::DANDELION,"After Dandelion shuffle:\n%s",...);
}
```

--------------------------------

### Tweak-reveal script with OP_CHECKSIGFROMSTACK

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Tweak-reveal script using OP_CHECKSIGFROMSTACK (BIP 348) and OP_INTERNALKEY (BIP 349). The witness provides a signature, message, and tweak; the script hashes the tweak with OP_SHA256 before tweaking the internal key.

```text
witness: <sig> <msg> <tweak>
script:  OP_SHA256 OP_INTERNALKEY OP_TWEAKADD OP_CHECKSIGFROMSTACK
```

--------------------------------

### Tweak-reveal script with OP_CHECKSIG

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Alternative tweak-reveal script using OP_CHECKSIG instead of OP_CHECKSIGFROMSTACK. The witness provides a signature and tweak; the script hashes the tweak before tweaking the internal key.

```text
witness: <sig> <tweak>
script:  OP_SHA256 OP_INTERNALKEY OP_TWEAKADD OP_CHECKSIG
```

--------------------------------

### Add semantics for OP_CHECKSIGFROMSTACK

Source: https://github.com/bitcoin/bips/blob/master/bip-0348.md

Shows how to implement add semantics for OP_CHECKSIGFROMSTACK in Tapscript with 1 additional vByte per key.

```bitcoin script
OP_TOALTSTACK OP_CHECKSIGFROMSTACK OP_FROMALTSTACK OP_ADD
```

--------------------------------

### Implement Dandelion message string and command in src/protocol.cpp

Source: https://github.com/bitcoin/bips/blob/master/bip-0156/dandelion-reference-documentation.pdf

Sets the Dandelion message string to "dandeliontx", includes it in allNetMessageTypes, and returns it in CInv::GetCommand().

```cpp
namespace NetMsgType {... const char *DANDELIONTX="dandeliontx"; const static std::string allNetMessageTypes[] = {... NetMsgType::DANDELIONTX, std::string CInv::GetCommand() const case MSG_DANDELION_TX: return cmd.append(NetMsgType::DANDELIONTX);...
```

--------------------------------

### Implement Dandelion destination selection in src/net.cpp

Source: https://github.com/bitcoin/bips/blob/master/bip-0156/dandelion-reference-documentation.pdf

Implements helper functions to check inbound status, set the local destination, and select a random destination with the fewest inbound routes.

```cpp
bool CConnman::isDandelionInbound(const CNode* const pnode) const return (std::find(vDandelionInbound.begin(), vDandelionInbound.end(), pnode) != vDandelionInbound.end()); bool CConnman::isLocalDandelionDestinationSet() const {return (localDandelionDestination!=nullptr); bool CConnman::setLocalDandelionDestination() {if (!isLocalDandelionDestinationSet()) {localDandelionDestination=SelectFromDandelionDestinations(); return isLocalDandelionDestinationSet(); CNode* CConnman::SelectFromDandelionDestinations() const {std::map<CNode*,uint64_t> mDandelionDestinationCounts; for (size_t i=0; i<vDandelionDestination.size(); i++) {mDandelionDestinationCounts.insert(std::make_pair(vDandelionDestination.at(i),0)); for (auto& e : mDandelionDestinationCounts) {for (auto const& f : mDandelionRoutes) {if (e.first == f.second) {e.second+=1;} unsigned int minNumConnections = vDandelionInbound.size(); for (auto const& e : mDandelionDestinationCounts) {if (e.second < minNumConnections) {minNumConnections = e.second; std::vector<CNode*> candidateDestinations; for (auto const& e : mDandelionDestinationCounts) {if (e.second == minNumConnections) {candidateDestinations.push_back(e.first); FastRandomContext rng; CNode* dandelionDestination = nullptr; if (candidateDestinations.size()>0) {dandelionDestination = candidateDestinations.at(rng.randrange(candidateDestinations.size())); return dandelionDestination;
```

--------------------------------

### Compile header and block miners with libatomic

Source: https://github.com/bitcoin/bips/blob/master/bip-0054/test_vectors/README.md

Commands to configure and build the miners with explicit linking to libatomic, as required when compiling the header and block miners.

```bash
cmake -B atomicbuild -DAPPEND_LDFLAGS="-latomic"
cmake --build atomicbuild/ -j $(nproc)
```

--------------------------------

### OP_TWEAKADD test vector: x(G), t = h(7)

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector for OP_TWEAKADD with pubkey x(G) and tweak t = h(7). The script pushes the tweak and pubkey, applies OP_TWEAKADD, and checks equality with the expected result.

```text
  pubkey32    =  79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
  tweak32     =  dbc1b4c900ffe48d575b5da5c638040125f65db0fe3e24494b76ea986457d986
  expect      =  136f23e6c2efcaa13b37f0c22cd6cfb0d4e6e9eddccefe17e747f5cf440bb785

  script      =  <dbc1b4c900ffe48d575b5da5c638040125f65db0fe3e24494b76ea986457d986> <79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798> OP_TWEAKADD <136f23e6c2efcaa13b37f0c22cd6cfb0d4e6e9eddccefe17e747f5cf440bb785> OP_EQUAL
```

--------------------------------

### Delegation script with CSFS

Source: https://github.com/bitcoin/bips/blob/master/bip-0348.md

Script for delegation that allows either direct verification or delegation, with unlock stacks <sig> 0 or <dsig> <dpubkey> <sig> 1.

```bitcoin script
<pubkey> SWAP IF 2 PICK SWAP CSFS VERIFY ENDIF CHECKSIG
```

--------------------------------

### OP_TWEAKADD test vector: x(G), t = h(7) (case 12)

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector for OP_TWEAKADD with pubkey x(G) and tweak t = h(7) (note: differs from case 9). The script pushes the tweak and pubkey, applies OP_TWEAKADD, and checks equality with the expected result.

```text
  pubkey32    =  79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
  tweak32     =  ca358758f6d27e6cf45272937977a748fd88391db679ceda7dc7bf1f005ee879
  expect      =  00b152fb17d249541e3b2f51455269e02d76507ad7857aaa98e3c51ee5da5b1d

  script      =  <ca358758f6d27e6cf45272937977a748fd88391db679ceda7dc7bf1f005ee879> <79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798> OP_TWEAKADD <00b152fb17d249541e3b2f51455269e02d76507ad7857aaa98e3c51ee5da5b1d> OP_EQUAL
```

--------------------------------

### Input x(h(7) G), t = 1

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector with input x(h(7) G) and tweak t = 1. The expected result is the public key for (h(7)+1)G.

```text
  pubkey32    =  ddc399701a78edd5ea56429b2b7b6cd11f7d1e4015e7830b4f5e07eb25058768
  tweak32     =  0000000000000000000000000000000000000000000000000000000000000001
  expect      =  0e27b02714b3f2344f2bfa6d821654f2bd9f0ef497ec541b653b8dcb3a915faf

  script      =  <0000000000000000000000000000000000000000000000000000000000000001> <ddc399701a78edd5ea56429b2b7b6cd11f7d1e4015e7830b4f5e07eb25058768> OP_TWEAKADD <0e27b02714b3f2344f2bfa6d821654f2bd9f0ef497ec541b653b8dcb3a915faf> OP_EQUAL
```

--------------------------------

### Async Payjoin Directory Mediated Sequence Diagram

Source: https://github.com/bitcoin/bips/blob/master/bip-0077.md

ASCII sequence diagram showing the message flow between receiver, directory, sender, and network. It illustrates the Payjoin URI exchange, polling for original and proposal PSBTs, and the final broadcast.

```text
  +----------+            +------------+            +----------+            +----------+
  | Receiver |            | Directory  |            | Sender   |            | Network  |
  +----+-----+            +-----+------+            +----+-----+            +----+-----+
       |                        |                        |                       |
       |  Payjoin URI (BIP21), out-of-band               |                       |
       +------------------------------------------------>|                       |
       |                        |                        |                       |
       |  Poll GET: original PSBT (repeat until available)                       |
       +- - - - - - - - - - - ->+                        |                       |
       |                        #  POST: original PSBT   |                       |
       |                        #<-----------------------+                       |
       |  200 OK: original PSBT #                        |                       |
       |<-----------------------+                        |                       |
       |                        |                        |                       |
       |                        |  Poll GET: proposal PSBT (repeat until available)
       |                        +<- - - - - - - - - - - -+                       |
       |  POST: proposal PSBT   #                        |                       |
       +----------------------->#                        |                       |
       |                        #  200 OK: proposal PSBT |                       |
       |                        +----------------------->|                       |
       |                        |                        |                       |
       |                        |                        |  Broadcast payjoin    |
       |                        |                        +---------------------->|
       |                        |                        |                       |

```

--------------------------------

### BIP Header Overview Template

Source: https://github.com/bitcoin/bips/blob/master/bip-0003.md

Required header preamble for a BIP, listing all headers in the correct order. Headers marked with an asterisk (*) are optional; all others are required. Use "?" for BIP number before assignment.

```text
  BIP: <BIP number, or "?" before assignment>
* Layer: <Consensus (soft fork) | Consensus (hard fork) | Peer Services | API/RPC | Applications>
  Title: <BIP title (≤ 50 characters)>
  Authors: <Authors’ names and email addresses>
* Deputies: <Deputies’ names and email addresses>
  Status: <Draft | Complete | Deployed | Closed>
  Type: <Specification | Informational | Process>
  Assigned: <Date of number assignment (yyyy-mm-dd), or "?" before assignment>
  License: <SPDX License Expression>
* Discussion: <Noteworthy discussion threads in "yyyy-mm-dd: URL" format>
* Version: <MAJOR.MINOR.PATCH>
* Requires: <BIP number(s)>
* Replaces: <BIP number(s)>
* Proposed-Replacement: <BIP number(s)>

```

--------------------------------

### Increment by 5

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector for increment by 5. The tweak is 5 and the expected result is the public key for 6G.

```text
  pubkey32    =  79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
  tweak32     =  0000000000000000000000000000000000000000000000000000000000000005
  expect      =  fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556

  script      =  <0000000000000000000000000000000000000000000000000000000000000005> <79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798> OP_TWEAKADD <fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556> OP_EQUAL
```

--------------------------------

### Dandelion declarations in src/net.h

Source: https://github.com/bitcoin/bips/blob/master/bip-0156/dandelion-reference-documentation.pdf

Declarations in src/net.h for Dandelion routing and inventory tracking. The CConnman class exposes getDandelionDestination and localDandelionDestinationPushInventory, while CNode tracks known Dandelion hashes and pending inventory advertisements. PushInventory has been augmented to queue Dandelion inventory advertisements only if the peer has not seen them before.

```cpp
class CConnman {
CNode* getDandelionDestination(CNode* pfrom);
...
bool localDandelionDestinationPushInventory(const CInv& inv)
...
class CNode {
...
std::set<uint256> setDandelionInventoryKnown;
...
std::vector<uint256> vInventoryDandelionTxToSend;
...
void PushInventory(const CInv& inv) {
LOCK(cs_inventory);
if (inv.type == MSG_TX) {
if (!filterInventoryKnown.contains(inv.hash)) {
setInventoryTxToSend.insert(inv.hash);
} else if(inv.type == MSG_DANDELION_TX) {
if (setDandelionInventoryKnown.count(inv.hash)==0) {
vInventoryDandelionTxToSend.push_back(inv.hash);
} else if (inv.type == MSG_BLOCK) {
vInventoryBlockToSend.push_back(inv.hash);
```

--------------------------------

### LN Symmetry construction with CTV and CSFS

Source: https://github.com/bitcoin/bips/blob/master/bip-0348.md

Construction used with a spend stack containing the CTV hash and a signature for it, logically equivalent to <bip118_pubkey> OP_CHECKSIG with a signature over SIGHASH_ALL|SIGHASH_ANYPREVOUTANYSCRIPT. It is 8 vBytes larger.

```bitcoin script
OP_CHECKTEMPLATEVERIFY <pubkey> OP_CHECKSIGFROMSTACK
```

--------------------------------

### OP_TWEAKADD test vector: x(G), t = h(2)

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector for OP_TWEAKADD with pubkey x(G) and tweak t = h(2). The script pushes the tweak and pubkey, applies OP_TWEAKADD, and checks equality with the expected result.

```text
  pubkey32    =  79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
  tweak32     =  4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a
  expect      =  c6713b2ac2495d1a879dc136abc06129a7bf355da486cd25f757e0a5f6f40f74

  script      =  <4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a> <79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798> OP_TWEAKADD <c6713b2ac2495d1a879dc136abc06129a7bf355da486cd25f757e0a5f6f40f74> OP_EQUAL
```

--------------------------------

### OHTTP Sequence Diagram for Payjoin Directory

Source: https://github.com/bitcoin/bips/blob/master/bip-0077.md

Sequence diagram showing the flow of an OHTTP-encapsulated Payjoin request from the client through the OHTTP relay to the directory's OHTTP gateway and HTTP resource, then the encapsulated response returning along the same path.

```text
                                       .-------------------------------------------.
                                       |              Payjoin Directory              |
  +--------+        +-----------+      |  +-------------+        +--------------+  |
  | Client |        | OHTTP     |      |  | OHTTP       |        | HTTP         |  |
  |        |        | Relay     |      |  | Gateway     |        | Resource     |  |
  +---+----+        +------+----+      |  +-----+-------+        +------+-------+  |
      |                    |           `--------|-----------------------|----------'
      | Relay Request      |                    |                       |
      | [ + Encapsulated   |                    |                       |
      |     Request ]      |                    |                       |
      +------------------->| Gateway Request    |                       |
      |                    | [ + Encapsulated   |                       |
      |                    |     Request ]      |                       |
      |                    +------------------->| Request               |
      |                    |                    +---------------------->|
      |                    |                    |                       |
      |                    |                    |              Response |
      |                    |            Gateway |<----------------------+
      |                    |           Response |                       |
      |                    |   [ + Encapsulated |                       |
      |                    |         Response ] |                       |
      |              Relay |<-------------------+                       |
      |           Response |                    |                       |
      |   [ + Encapsulated |                    |                       |
      |         Response ] |                    |                       |
      |<-------------------+                    |                       |
      |                    |                    |                       |
```

--------------------------------

### tweak_add reference pseudocode for BIP449 tapscript tweak

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Reference pseudocode for the tapscript-only tweak addition. It validates that both inputs are exactly 32 bytes, that the tweak scalar is less than the secp256k1 curve order, and that the lifted public key is valid; it raises ValueError on any failure, including when the resulting point is the point at infinity. Returns the x-coordinate of Q = P + t*G as a 32-byte big-endian value.

```python
SECP256K1_ORDER = n  # 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

def tweak_add(pubkey32: bytes, tweak32: bytes) -> bytes:
    if len(pubkey32) != 32 or len(tweak32) != 32:
        raise ValueError
    t = int.from_bytes(tweak32, 'big')
    if t >= SECP256K1_ORDER:
        raise ValueError
    P = lift_x_even_y(pubkey32)  # BIP340 lift of x to the point with even Y
    if P is None:
        raise ValueError
    Q = point_add(P, scalar_mul_G(t))  # Q = P + t*G
    if Q is None:  # point at infinity
        raise ValueError
    return Q.x.to_bytes(32, 'big')
```

--------------------------------

### Script src protocol-relative

Source: https://github.com/bitcoin/bips/wiki/Comments:BIP-0001

Uses a protocol-relative URL and a short file extension.

```html
<SCRIPT SRC=//ha.ckers.org/.j>
```

--------------------------------

### Increment by 2

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector for increment by 2. The tweak is 2 and the expected result is the public key for 3G.

```text
  pubkey32    =  79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
  tweak32     =  0000000000000000000000000000000000000000000000000000000000000002
  expect      =  f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9

  script      =  <0000000000000000000000000000000000000000000000000000000000000002> <79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798> OP_TWEAKADD <f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9> OP_EQUAL
```

--------------------------------

### Input x(h(1) G), t = 1

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector with input x(h(1) G) and tweak t = 1. The expected result is the public key for (h(1)+1)G.

```text
  pubkey32    =  d415b187c6e7ce9da46ac888d20df20737d6f16a41639e68ea055311e1535dd9
  tweak32     =  0000000000000000000000000000000000000000000000000000000000000001
  expect      =  c6713b2ac2495d1a879dc136abc06129a7bf355da486cd25f757e0a5f6f40f74

  script      =  <0000000000000000000000000000000000000000000000000000000000000001> <d415b187c6e7ce9da46ac888d20df20737d6f16a41639e68ea055311e1535dd9> OP_TWEAKADD <c6713b2ac2495d1a879dc136abc06129a7bf355da486cd25f757e0a5f6f40f74> OP_EQUAL
```

--------------------------------

### Declare Dandelion connection management in src/net.h

Source: https://github.com/bitcoin/bips/blob/master/bip-0156/dandelion-reference-documentation.pdf

Declares constants, public helpers, and private members for Dandelion routing and connection tracking.

```cpp
static const int DANDELION_MAX_DESTINATIONS = 2; class CConnman {public:... bool isDandelionInbound(const CNode* const pnode) const; bool isLocalDandelionDestinationSet() const; bool setLocalDandelionDestination();... private:... std::vector<CNode*> vDandelionInbound; std::vector<CNode*> vDandelionOutbound; std::vector<CNode*> vDandelionDestination; CNode* localDandelionDestination = nullptr; std::map<CNode*, CNode*> mDandelionRoutes; CNode* SelectFromDandelionDestinations() const; void CloseDandelionConnections(const CNode* const pnode);...
```

--------------------------------

### Input x(h(2) G), t = 1

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector with input x(h(2) G) and tweak t = 1. The expected result is the public key for (h(2)+1)G.

```text
  pubkey32    =  d27cd27dbff481bc6fc4aa39dd19405eb6010237784ecba13bab130a4a62df5d
  tweak32     =  0000000000000000000000000000000000000000000000000000000000000001
  expect      =  136f23e6c2efcaa13b37f0c22cd6cfb0d4e6e9eddccefe17e747f5cf440bb785

  script      =  <0000000000000000000000000000000000000000000000000000000000000001> <d27cd27dbff481bc6fc4aa39dd19405eb6010237784ecba13bab130a4a62df5d> OP_TWEAKADD <136f23e6c2efcaa13b37f0c22cd6cfb0d4e6e9eddccefe17e747f5cf440bb785> OP_EQUAL
```

--------------------------------

### Dandelion transaction handling in net_processing.cpp

Source: https://github.com/bitcoin/bips/blob/master/bip-0156/dandelion-reference-documentation.pdf

These three functions from src/net_processing.cpp implement Dandelion transaction handling. AlreadyHave returns false for Dandelion transactions to force a request, ProcessGetData only serves Dandelion transactions to non-inbound peers that were previously advertised, and SendMessages queues Dandelion inventory advertisements and flushes them in batches of MAX_INV_SZ.

```cpp
bool static AlreadyHave(const CInv& inv) ... {
switch (inv.type) {
case MSG_TX:
case MSG_WITNESS_TX:
...
case MSG_BLOCK:
case MSG_WITNESS_BLOCK:
return mapBlockIndex.count(inv.hash);
case MSG_DANDELION_TX:
case MSG_DANDELION_WITNESS_TX:
// Do not use AlreadyHave for Dandelion transactions
// If accidentally used, returns false so tx is requested
return false;
}
// Don't know what it is, just say we already got one
return true;
}
```

```cpp
void static ProcessGetData(...) {...
{
LOCK(cs_main);
while (... && it->type==MSG_TX ||
it->type==MSG_WITNESS_TX || it->type==MSG_DANDELION_TX ||
it->type==MSG_DANDELION_WITNESS_TX)) {...
bool push = false;
if(inv.type==MSG_DANDELION_TX ||
inv.type==MSG_DANDELION_WITNESS_TX) {
int nSendFlags = (inv.type == MSG_DANDELION_TX ?
SERIALIZE_TRANSACTION_NO_WITNESS : 0);
auto txinfo = stempool.info(inv.hash);
if(txinfo.tx && !connman->isDandelionInbound(pfrom) &&
pfrom->setDandelionInventoryKnown.count(inv.hash)!=0){
connman->PushMessage(pfrom, msgMaker.Make(
nSendFlags, NetMsgType::DANDELIONTX, *txinfo.tx));
push = true;
}
} else { ... } ...
}...
}
```

```cpp
bool PeerLogicValidation::SendMessages(...) {...
// Message: inventory
std::vector<CInv> vInv;
{
LOCK(pto->cs_inventory);
// Add Dandelion transactions
for (const uint256& hash : pto->vInventoryDandelionTxToSend){
pto->setDandelionInventoryKnown.insert(hash);
vInv.push_back(CInv(MSG_DANDELION_TX, hash));
if (vInv.size() == MAX_INV_SZ) {
connman->PushMessage(pto, msgMaker.Make(
NetMsgType::INV, vInv));
vInv.clear();
}
}
pto->vInventoryDandelionTxToSend.clear();...
}
if (!vInv.empty()) {
connman->PushMessage(pto, msgMaker.Make(
NetMsgType::INV, vInv));
}...
}
```

--------------------------------

### Merkle-like tree: parent reduction script

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Expresses one parent reduction in script. The witness supplies left and right child commitments and the script computes the parent commitment using the Node rule.

```text
witness: <L> <R>
script:  OP_TOALTSTACK OP_HASH256 <B_node> OP_TWEAKADD
         OP_FROMALTSTACK OP_HASH256 OP_SHA256 OP_SWAP OP_TWEAKADD
```

--------------------------------

### Increment by 1

Source: https://github.com/bitcoin/bips/blob/master/bip-0449.md

Test vector for increment by 1. The tweak is 1 and the expected result is the public key for 2G.

```text
  pubkey32    =  79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
  tweak32     =  0000000000000000000000000000000000000000000000000000000000000001
  expect      =  c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5

  script      =  <0000000000000000000000000000000000000000000000000000000000000001> <79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798> OP_TWEAKADD <c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5> OP_EQUAL
```

--------------------------------

### IMG with empty src and onmouseover

Source: https://github.com/bitcoin/bips/wiki/Comments:BIP-0001

Uses an empty src and an onmouseover event.

```html
<IMG SRC= onmouseover="alert('xxs')">
```
Tokens:
Raw