READ THE CODE

Inside Bitcoin

The code behind the network, with room to understand it.

Stable release v32.1bitcoin/bitcoin · f0de87f04062 ↗3,020 source files · 47.5 MB stored on the server340 file guides

Release published 2026-10-28 · Snapshot fetched 2026-11-01. Latest stable release at fetch time; development branches and Git history are excluded. Only the selected code window and visible folders load here.

19,628 bytes · SHA-256 b31e7e1f197e2386… · View upstream ↗

1/*************************************************************************
2 * To the extent possible under law, the author(s) have dedicated all    *
3 * copyright and related and neighboring rights to the software in this  *
4 * file to the public domain worldwide. This software is distributed     *
5 * without any warranty. For the CC0 Public Domain Dedication, see       *
6 * EXAMPLES_COPYING or https://creativecommons.org/publicdomain/zero/1.0 *
7 *************************************************************************/
8
9#include <assert.h>
10#include <stdio.h>
11#include <stdlib.h>
12#include <string.h>
13
14#include <secp256k1_extrakeys.h>
15#include <secp256k1_silentpayments.h>
16
17#include "examples_util.h"
18
19#define N_INPUTS  2
20#define N_OUTPUTS 3
21
22/* Static data for Bob and Carol's Silent Payments addresses */
23static unsigned char smallest_outpoint[36] = {
24    0x16, 0x9e, 0x1e, 0x83, 0xe9, 0x30, 0x85, 0x33, 0x91,
25    0xbc, 0x6f, 0x35, 0xf6, 0x05, 0xc6, 0x75, 0x4c, 0xfe,
26    0xad, 0x57, 0xcf, 0x83, 0x87, 0x63, 0x9d, 0x3b, 0x40,
27    0x96, 0xc5, 0x4f, 0x18, 0xf4, 0x00, 0x00, 0x00, 0x00
28};
29static unsigned char bob_scan_key[32] = {
30    0xa8, 0x90, 0x54, 0xc9, 0x5b, 0xe3, 0xc3, 0x01,
31    0x56, 0x65, 0x74, 0xf2, 0xaa, 0x93, 0xad, 0xe0,
32    0x51, 0x85, 0x09, 0x03, 0xa6, 0x9c, 0xbd, 0xd1,
33    0xd4, 0x7e, 0xae, 0x26, 0x3d, 0x7b, 0xc0, 0x31
34};
35static unsigned char bob_spend_key[32] = {
36    0x9d, 0x6a, 0xd8, 0x55, 0xce, 0x34, 0x17, 0xef,
37    0x84, 0xe8, 0x36, 0x89, 0x2e, 0x5a, 0x56, 0x39,
38    0x2b, 0xfb, 0xa0, 0x5f, 0xa5, 0xd9, 0x7c, 0xce,
39    0xa3, 0x0e, 0x26, 0x6f, 0x54, 0x0e, 0x08, 0xb3
40};
41static unsigned char bob_scan_and_spend_pubkeys[2][33] = {
42    {
43        0x02, 0x15, 0x40, 0xae, 0xa8, 0x97, 0x54, 0x7a,
44        0xd4, 0x39, 0xb4, 0xe0, 0xf6, 0x09, 0xe5, 0xf0,
45        0xfa, 0x63, 0xde, 0x89, 0xab, 0x11, 0xed, 0xe3,
46        0x1e, 0x8c, 0xde, 0x4b, 0xe2, 0x19, 0x42, 0x5f, 0x23
47    },
48    {
49        0x02, 0x5c, 0xc9, 0x85, 0x6d, 0x6f, 0x83, 0x75,
50        0x35, 0x0e, 0x12, 0x39, 0x78, 0xda, 0xac, 0x20,
51        0x0c, 0x26, 0x0c, 0xb5, 0xb5, 0xae, 0x83, 0x10,
52        0x6c, 0xab, 0x90, 0x48, 0x4d, 0xcd, 0x8f, 0xcf, 0x36
53    }
54};
55static unsigned char carol_scan_key[32] = {
56    0x04, 0xb2, 0xa4, 0x11, 0x63, 0x5c, 0x09, 0x77,
57    0x59, 0xaa, 0xcd, 0x0f, 0x00, 0x5a, 0x4c, 0x82,
58    0xc8, 0xc9, 0x28, 0x62, 0xc6, 0xfc, 0x28, 0x4b,
59    0x80, 0xb8, 0xef, 0xeb, 0xc2, 0x0c, 0x3d, 0x17
60};
61static unsigned char carol_address[2][33] = {
62    {
63        0x03, 0xbb, 0xc6, 0x3f, 0x12, 0x74, 0x5d, 0x3b,
64        0x9e, 0x9d, 0x24, 0xc6, 0xcd, 0x7a, 0x1e, 0xfe,
65        0xba, 0xd0, 0xa7, 0xf4, 0x69, 0x23, 0x2f, 0xbe,
66        0xcf, 0x31, 0xfb, 0xa7, 0xb4, 0xf7, 0xdd, 0xed, 0xa8
67    },
68    {
69        0x03, 0x81, 0xeb, 0x9a, 0x9a, 0x9e, 0xc7, 0x39,
70        0xd5, 0x27, 0xc1, 0x63, 0x1b, 0x31, 0xb4, 0x21,
71        0x56, 0x6f, 0x5c, 0x2a, 0x47, 0xb4, 0xab, 0x5b,
72        0x1f, 0x6a, 0x68, 0x6d, 0xfb, 0x68, 0xea, 0xb7, 0x16
73    }
74};
75
76/** Labels
77 *
78 *  The structs and callback function are implemented here as a demonstration
79 *  of how the label lookup callback is meant to query a label cache and return
80 *  the label tweak when a match is found. This is for demonstration purposes
81 *  only and not optimized. In production, it is expected that the
82 *  caller will be using a much more performant data structure for storing and
83 *  querying labels, like e.g. a hash table with O(1) lookup cost.
84 *
85 *  Recipients not using labels can ignore these steps and simply pass `NULL`
86 *  for the label_lookup and label_context arguments:
87 *
88 *      secp256k1_silentpayments_recipient_scan_outputs(..., NULL, NULL);
89 */
90
91struct label_cache_entry {
92    unsigned char label[33];
93    unsigned char label_tweak[32];
94};
95
96struct labels_cache {
97    size_t entries_used;
98    struct label_cache_entry entries[5];
99};
100
101const unsigned char* label_lookup(
102    const unsigned char* label33,
103    const void* cache_ptr
104) {
105    const struct labels_cache* cache = (const struct labels_cache*)cache_ptr;
106    size_t i;
107    for (i = 0; i < cache->entries_used; i++) {
108        if (memcmp(cache->entries[i].label, label33, 33) == 0) {
109            return cache->entries[i].label_tweak;
110        }
111    }
112    return NULL;
113}
114
115int main(void) {
116    unsigned char randomize[32];
117    unsigned char serialized_xonly[32];
118    secp256k1_xonly_pubkey tx_inputs[N_INPUTS];
119    const secp256k1_xonly_pubkey *tx_input_ptrs[N_INPUTS];
120    secp256k1_xonly_pubkey tx_outputs[N_OUTPUTS];
121    secp256k1_xonly_pubkey *tx_output_ptrs[N_OUTPUTS];
122    secp256k1_silentpayments_found_output found_outputs[N_OUTPUTS];
123    secp256k1_silentpayments_found_output *found_output_ptrs[N_OUTPUTS];
124    secp256k1_silentpayments_prevouts_summary prevouts_summary;
125    secp256k1_pubkey unlabeled_spend_pubkey;
126    struct labels_cache bob_labels_cache;
127    unsigned char bob_address[2][33];
128    int ret;
129    size_t i;
130    uint32_t n_found_outputs;
131
132    /* Before we can call actual API functions, we need to create a "context" */
133    secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
134    if (!fill_random(randomize, sizeof(randomize))) {
135        printf("Failed to generate randomness\n");
136        return EXIT_FAILURE;
137    }
138    /* Randomizing the context is recommended to protect against side-channel
139     * leakage. See `secp256k1_context_randomize` in secp256k1.h for more
140     * information about it. This should never fail. */
141    ret = secp256k1_context_randomize(ctx, randomize);
142    assert(ret);
143
144    /* Set up the pointer arrays. These will be used for sending and scanning. */
145    for (i = 0; i < N_INPUTS; i++) {
146        tx_input_ptrs[i] = &tx_inputs[i];
147    }
148    for (i = 0; i < N_OUTPUTS; i++) {
149        tx_output_ptrs[i] = &tx_outputs[i];
150        found_output_ptrs[i] = &found_outputs[i];
151    }
152
153    /*** Create a labeled Silent Payments address (Bob) ***/
154    {
155        size_t len = 33;
156        secp256k1_silentpayments_label label;
157        secp256k1_pubkey labeled_spend_pubkey;
158        /* Per BIP-352, the label integer value m = 0 is reserved for the receiver's own
159         * change, so only values m >= 1 must be used for publishing addresses. */
160        uint32_t m = 1;
161
162        /* Load Bob's spend public key */
163        ret = secp256k1_ec_pubkey_parse(ctx,
164            &unlabeled_spend_pubkey,
165            bob_scan_and_spend_pubkeys[1],
166            33
167        );
168        assert(ret);
169        /* Create a (label_tweak, label) pair and add them to the labels cache.
170         *
171         * Bob MUST keep track of all of the labels he has used by adding them
172         * to the labels cache. Otherwise, he will not find outputs sent to his
173         * labeled addresses when scanning. */
174        ret = secp256k1_silentpayments_recipient_label_create(ctx,
175            &label,
176            bob_labels_cache.entries[0].label_tweak,
177            bob_scan_key,
178            m
179        );
180        if (!ret) {
181            printf("Something went wrong, event with negligible probability happened.\n");
182            return EXIT_FAILURE;
183        }
184        ret = secp256k1_silentpayments_recipient_label_serialize(ctx, bob_labels_cache.entries[0].label, &label);
185        assert(ret);
186        bob_labels_cache.entries_used = 1;
187        /* Now that the labels cache has been updated, Bob creates his labeled
188         * Silent Payments address and publishes it.
189         */
190        ret = secp256k1_silentpayments_recipient_create_labeled_spend_pubkey(ctx, &labeled_spend_pubkey, &unlabeled_spend_pubkey, &label);
191        if (!ret) {
192            printf("Something went wrong, event with negligible probability happened.\n");
193            return EXIT_FAILURE;
194        }
195        memcpy(bob_address[0], bob_scan_and_spend_pubkeys[0], 33);
196        ret = secp256k1_ec_pubkey_serialize(ctx,
197            bob_address[1],
198            &len,
199            &labeled_spend_pubkey,
200            SECP256K1_EC_COMPRESSED
201        );
202        assert(ret);
203    }
204    /*** Sending (Alice) ***/
205    {
206        secp256k1_keypair sender_keypairs[N_INPUTS];
207        const secp256k1_keypair *sender_keypair_ptrs[N_INPUTS];
208        secp256k1_silentpayments_recipient recipients[N_OUTPUTS];
209        const secp256k1_silentpayments_recipient *recipient_ptrs[N_OUTPUTS];
210        /* 2D array for holding multiple public key pairs. The second index, i.e., [2],
211         * is to represent the spend and scan public keys. */
212        unsigned char (*sp_addresses[N_OUTPUTS])[2][33];
213        unsigned char seckey[32];
214
215        /*** Generate secret keys for the sender ***
216         *
217         * In this example, only taproot inputs are used but the function can be
218         * called with a mix of taproot seckeys and plain seckeys. Taproot
219         * seckeys are passed as keypairs to allow the sending function to check
220         * if the secret keys need to be negated without needing to do an
221         * expensive pubkey generation. This is not needed for plain seckeys
222         * since there is no need for negation.
223         *
224         * The public key from each input keypair is saved in the `tx_inputs`
225         * array. This array will be used later in the example to represent the
226         * public keys the recipient will extract from the transaction inputs.
227         *
228         * If the secret key is zero or out of range (bigger than secp256k1's
229         * order), fail. Note that the probability of this happening is
230         * negligible. */
231        for (i = 0; i < N_INPUTS; i++) {
232            if (!fill_random(seckey, sizeof(seckey))) {
233                printf("Failed to generate randomness\n");
234                return EXIT_FAILURE;
235            }
236            /* Try to create a keypair with a valid context, it should only fail
237             * if the secret key is zero or out of range. */
238            if (secp256k1_keypair_create(ctx, &sender_keypairs[i], seckey)) {
239                sender_keypair_ptrs[i] = &sender_keypairs[i];
240                ret = secp256k1_keypair_xonly_pub(
241                    ctx,
242                    &tx_inputs[i],
243                    NULL,
244                    &sender_keypairs[i]
245                );
246                assert(ret);
247            } else {
248                printf("Failed to create keypair\n");
249                return EXIT_FAILURE;
250            }

src/wallet/receive.cpp

src/wallet/coinselection.cpp

src/consensus/validation.h

src/primitives/transaction.cpp

src/script/descriptor.cpp

src/bitcoin-cli.cpp

src/rpc/blockchain.cpp

src/rpc/rawtransaction.cpp

src/init.cpp

src/crypto/sha256.cpp

src/consensus/merkle.h

src/consensus/tx_check.h

src/consensus/tx_verify.h

src/policy/feerate.h

src/policy/feerate.cpp

src/primitives/transaction_identifier.h

src/chainparamsbase.h

src/chainparamsbase.cpp

src/util/moneystr.cpp

src/crypto/ripemd160.h

src/crypto/sha1.h

src/crypto/sha512.h

src/crypto/hmac_sha256.h

src/crypto/hmac_sha512.h

src/crypto/hmac_sha256.cpp

src/crypto/hmac_sha512.cpp

src/crypto/hkdf_sha256_32.h

src/crypto/hkdf_sha256_32.cpp

src/support/cleanse.h

src/support/cleanse.cpp

src/crypto/siphash.cpp

src/crypto/muhash.h

src/crypto/chacha20.h

src/crypto/poly1305.h

src/crypto/chacha20poly1305.h

src/crypto/chacha20poly1305.cpp

src/util/chaintype.cpp

src/util/obfuscation.h

src/util/byte_units.h

src/util/overflow.h

src/blockencodings.cpp

src/net_permissions.cpp

src/policy/packages.cpp

src/policy/rbf.cpp

src/policy/truc_policy.cpp

src/policy/ephemeral_policy.cpp

src/policy/settings.cpp

src/policy/policy.cpp

src/node/transaction.cpp

src/node/coin.cpp

src/rpc/client.cpp

src/rpc/external_signer.cpp

src/rpc/request.cpp

src/rpc/server_util.cpp

src/rpc/fees.cpp

src/rpc/output_script.cpp

src/rpc/rawtransaction_util.cpp

src/rpc/rawtransaction_util.h

src/rpc/register.h

src/rpc/request.h

src/rpc/server_util.h

src/rpc/protocol.h

src/rpc/server.h

src/rpc/signmessage.cpp

src/rpc/txoutproof.cpp

src/rpc/util.cpp

src/rpc/util.h

src/wallet/rpc/addresses.cpp

src/wallet/rpc/backup.cpp

src/wallet/rpc/coins.cpp

src/wallet/rpc/encrypt.cpp

src/wallet/rpc/signmessage.cpp

src/wallet/rpc/util.cpp

src/wallet/rpc/util.h

src/wallet/coincontrol.cpp

src/wallet/coincontrol.h

src/wallet/context.cpp

src/wallet/context.h

src/wallet/crypter.cpp

src/wallet/crypter.h

src/wallet/db.cpp

src/wallet/export.cpp

src/wallet/external_signer_scriptpubkeyman.cpp

src/wallet/rpc/spend.cpp

src/wallet/rpc/transactions.cpp

src/wallet/rpc/wallet.cpp

src/wallet/feebumper.cpp

src/wallet/feebumper.h

src/index/base.h

src/index/base.cpp

src/index/txindex.h

src/index/txindex.cpp

src/index/txindex_key.h

src/index/txospenderindex.h

src/index/txospenderindex.cpp

src/index/blockfilterindex.h

src/index/blockfilterindex.cpp

src/index/coinstatsindex.h

src/index/coinstatsindex.cpp

src/index/db_key.h

src/index/disktxpos.h

src/kernel/chain.cpp

src/kernel/chain.h

src/kernel/checks.cpp

src/kernel/checks.h

src/kernel/context.cpp

src/kernel/context.h

src/kernel/cs_main.cpp

src/kernel/cs_main.h

src/kernel/disconnected_transactions.cpp

src/kernel/disconnected_transactions.h

src/kernel/mempool_removal_reason.cpp

src/kernel/mempool_removal_reason.h

src/kernel/coinstats.cpp

src/kernel/coinstats.h

src/kernel/chainparams.cpp

src/kernel/chainparams.h

src/wallet/sqlite.cpp

src/wallet/sqlite.h

src/wallet/transaction.cpp

src/wallet/transaction.h

src/wallet/dump.cpp

src/wallet/dump.h

src/wallet/init.cpp

src/wallet/walletutil.cpp

src/wallet/walletutil.h

src/wallet/wallettool.cpp

src/wallet/wallettool.h

src/wallet/export.h

src/wallet/migrate.cpp

src/wallet/migrate.h

src/wallet/db.h

src/wallet/walletdb.cpp

src/wallet/interfaces.cpp

src/wallet/scriptpubkeyman.cpp

src/wallet/scriptpubkeyman.h

src/kernel/bitcoinkernel.cpp

src/kernel/bitcoinkernel.h

src/kernel/bitcoinkernel_wrapper.h

src/node/chainstate.cpp

src/node/chainstate.h

src/node/blockstorage.cpp

src/node/blockstorage.h

src/node/mempool_persist.cpp

src/node/mempool_persist.h

src/node/utxo_snapshot.cpp

src/node/utxo_snapshot.h

src/node/kernel_notifications.cpp

src/node/kernel_notifications.h

src/node/blockmanager_args.cpp

src/kernel/blockmanager_opts.h

src/util/expected.cpp

src/policy/settings.h

src/util/types.h

src/kernel/messagestartchars.h

src/kernel/warning.h

src/util/exception.h

src/common/license_info.h

src/node/coins_view_args.h

src/node/database_args.h

src/util/batchpriority.h

src/util/ui_change_type.h

src/node/coins_view_args.cpp

src/node/peerman_args.h

src/util/serfloat.h

src/node/blockmanager_args.h

src/node/database_args.cpp

src/util/overloaded.h

src/interfaces/types.h

src/node/chainstatemanager_args.h

src/node/minisketchwrapper.h

src/util/macros.h

src/util/syserror.h

src/common/run_command.h

src/util/bytevectorhash.cpp

src/node/mempool_persist_args.cpp

src/util/exec.h

src/util/rbf.h

src/crypto/hex_base.h

src/node/mempool_persist_args.h

src/interfaces/echo.h

src/util/any.h

src/util/batchpriority.cpp

src/util/threadnames.h

src/node/coin.h

src/node/mempool_args.h

src/util/asmap.h

src/util/bytevectorhash.h

src/node/context.cpp

src/util/insert.h

src/util/readwritefile.h

src/node/peerman_args.cpp

src/node/interface_ui.cpp

src/interfaces/handler.h

src/node/mining_args.h

src/util/hasher.cpp

src/common/init.h

src/kernel/mempool_limits.h

src/common/system.h

src/crypto/sha3.h

src/util/threadinterrupt.cpp

src/node/protocol_version.h

src/util/exception.cpp

src/common/messages.h

src/node/connection_types.cpp

src/util/bip32.h

src/common/license_info.cpp

src/util/stdmutex.h

src/common/run_command.cpp

src/util/check.cpp

src/util/golombrice.h

src/node/types.h

src/node/timeoffsets.h

src/util/readwritefile.cpp

src/util/fastrange.h

src/util/signalinterrupt.h

src/util/task_runner.h

src/util/syserror.cpp

src/common/interfaces.cpp

src/common/types.h

src/util/threadinterrupt.h

src/kernel/chainstatemanager_opts.h

src/node/psbt.h

src/policy/ephemeral_policy.h

src/util/trace.h

src/common/url.cpp

src/kernel/mempool_options.h

src/util/serfloat.cpp

src/kernel/notifications_interface.h

src/node/timeoffsets.cpp

src/node/warnings.cpp

src/util/hash_type.h

src/crypto/hex_base.cpp

src/node/eviction.h

src/util/tokenbucket.h

src/crypto/aes.h

src/common/pcp.h

src/util/feefrac.cpp

src/node/transaction.h

src/util/threadnames.cpp

src/common/signmessage.h

src/util/exec.cpp

src/util/signalinterrupt.cpp

Independent explanations by MyBitcoinExplorer. Not affiliated with or endorsed by Bitcoin Core. Guides are educational and do not replace the source or its tests.

Bitcoin Core source © its contributors, distributed under the MIT license. Original notices and bundled third-party licenses are retained in the source tree.