AC_ARG_ENABLE([hardening],

[AS_HELP_STRING([--disable-hardening],

[use_hardening=$enableval],

AC_ARG_ENABLE([reduce-exports],

[AS_HELP_STRING([--enable-reduce-exports],

[enable_debug=$enableval],

[enable_debug=no])

# Turn warnings into errors

AC_ARG_ENABLE([werror],

[AS_HELP_STRING([--enable-werror],

AC_SEARCH_LIBS([clock_gettime],[rt])

fi

if test x$TARGET_OS != xwindows; then

# All windows code is PIC, forcing it on just adds useless compile warnings

AX_CHECK_COMPILE_FLAG([-fPIC],[PIC_FLAGS="-fPIC"])

fi

if test x$use_hardening != xno; then

AX_CHECK_COMPILE_FLAG([-Wstack-protector],[HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -Wstack-protector"])

AX_CHECK_COMPILE_FLAG([-fstack-protector-all],[HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -fstack-protector-all"])

AC_SUBST(RELDFLAGS)

AC_SUBST(ERROR_CXXFLAGS)

AC_SUBST(HARDENED_CXXFLAGS)

AC_SUBST(HARDENED_CPPFLAGS)

AC_SUBST(HARDENED_LDFLAGS)

echo " with upnp = $use_upnp"

echo " use asm = $use_asm"

echo " debug enabled = $enable_debug"

echo " werror = $enable_werror"

echo

echo " target os = $TARGET_OS"

A small script to automatically create manpages in ../../doc/man by running the release binaries with the -help option.

This requires help2man which can be found at: https://www.gnu.org/software/help2man/

git-subtree-check.sh

====================

#!/bin/bash

TOPDIR=${TOPDIR:-$(git rev-parse --show-toplevel)}

MANDIR=${MANDIR:-$TOPDIR/doc/man}

[ ! -x $BITCOIND ] && echo "$BITCOIND not found or not executable." && exit 1

# Check for new lines in diff that introduce trailing whitespace.

# We can't run this check unless we know the commit range for the PR.

if [ -z "${TRAVIS_COMMIT_RANGE}" ]; then

fi

showdiff() {

fi

# Check if tab characters were found in the diff.

echo "This diff appears to have added new lines with tab characters instead of spaces."

echo "The following changes were suspected:"

FILENAME=""

fi

echo "$line"

fi

RET=1

fi

-S|--signer)

if [ -n "$2" ]

then

shift

else

echo 'Error: "--signer" requires a non-empty argument.'

# Get signer

if [[ -n "$1" ]]

then

shift

fi

fi

# Check that a signer is specified

then

echo "$scriptName: Missing signer."

echo "Try $scriptName --help for more information"

echo "Compiling ${VERSION} Linux"

echo ""

./bin/gbuild -j ${proc} -m ${mem} --commit bitcoin=${COMMIT} --url bitcoin=${url} ../bitcoin/contrib/gitian-descriptors/gitian-linux.yml

mv build/out/bitcoin-*.tar.gz build/out/src/bitcoin-*.tar.gz ../bitcoin-binaries/${VERSION}

fi

# Windows

echo "Compiling ${VERSION} Windows"

echo ""

./bin/gbuild -j ${proc} -m ${mem} --commit bitcoin=${COMMIT} --url bitcoin=${url} ../bitcoin/contrib/gitian-descriptors/gitian-win.yml

mv build/out/bitcoin-*-win-unsigned.tar.gz inputs/bitcoin-win-unsigned.tar.gz

mv build/out/bitcoin-*.zip build/out/bitcoin-*.exe ../bitcoin-binaries/${VERSION}

fi

echo "Compiling ${VERSION} Mac OSX"

echo ""

./bin/gbuild -j ${proc} -m ${mem} --commit bitcoin=${COMMIT} --url bitcoin=${url} ../bitcoin/contrib/gitian-descriptors/gitian-osx.yml

mv build/out/bitcoin-*-osx-unsigned.tar.gz inputs/bitcoin-osx-unsigned.tar.gz

mv build/out/bitcoin-*.tar.gz build/out/bitcoin-*.dmg ../bitcoin-binaries/${VERSION}

fi

echo "Committing ${VERSION} Unsigned Sigs"

echo ""

pushd gitian.sigs

git commit -a -m "Add ${VERSION} unsigned sigs for ${SIGNER}"

popd

fi

echo "Signing ${VERSION} Windows"

echo ""

./bin/gbuild -i --commit signature=${COMMIT} ../bitcoin/contrib/gitian-descriptors/gitian-win-signer.yml

mv build/out/bitcoin-*win64-setup.exe ../bitcoin-binaries/${VERSION}

mv build/out/bitcoin-*win32-setup.exe ../bitcoin-binaries/${VERSION}

fi

echo "Signing ${VERSION} Mac OSX"

echo ""

./bin/gbuild -i --commit signature=${COMMIT} ../bitcoin/contrib/gitian-descriptors/gitian-osx-signer.yml

mv build/out/bitcoin-osx-signed.dmg ../bitcoin-binaries/${VERSION}/bitcoin-${VERSION}-osx.dmg

fi

popd

echo ""

echo "Committing ${VERSION} Signed Sigs"

echo ""

git commit -a -m "Add ${VERSION} signed binary sigs for ${SIGNER}"

popd

fi

617C90010B3BD370B0AC7D424BB42E31C79111B8 Akira Takizawa

E944AE667CF960B1004BC32FCA662BE18B877A60 Andreas Schildbach

912FD3228387123DC97E0E57D5566241A0295FA9 BtcDrak

C519EBCF3B926298946783EFF6430754120EC2F4 Christian Decker (cdecker)

F20F56EF6A067F70E8A5C99FFF95FAA971697405 centaur

BF6273FAEF7CC0BA1F562E50989F6B3048A116B5 Dev Random

9A1689B60D1B3CCE9262307A2F40A9BF167FBA47 Erik Mossberg (erkmos)

D35176BE9264832E4ACA8986BF0792FBE95DC863 fivepiece

01CDF4627A3B88AAE4A571C87588242FBE38D3A8 Gavin Andresen

D3CC177286005BB8FF673294C5242A1AB3936517 jl2012

32EE5C4C3FA15CCADB46ABE529D4BCB6416F53EC Jonas Schnelli

4B4E840451149DD7FB0D633477DFAB5C3108B9A8 Jorge Timon

E463A93F5F3117EEDE6C7316BD02942421F4889F Luke Dashjr

B8B3F1C0E58C15DB6A81D30C3648A882F4316B9B Marco Falke

CA03882CB1FC067B5D3ACFE4D300116E1C875A3D MeshCollider

9692B91BBF0E8D34DFD33B1882C5C009628ECF0C Michagogo

D62A803E27E7F43486035ADBBCD04D8E9CCCAC2A Paul Rabahy

D762373D24904A3E42F33B08B9A408E71DAAC974 Pieter Wuille (Location: Leuven, Belgium)

133EAC179436F14A5CF1B794860FEB804E669320 Pieter Wuille

ED9BDF7AD6A55E232E84524257FF9BDBCC301009 Sjors Provoost

AEC1884398647C47413C1C3FB1179EB7347DC10D Warren Togami

class ZMQHandler():

def __init__(self):

self.zmqContext = zmq.asyncio.Context()

self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)

class ZMQHandler():

def __init__(self):

self.zmqContext = zmq.asyncio.Context()

self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)

host:=$(BUILD)

ifneq ($(HOST),)

host:=$(HOST)

endif

ifneq ($(DEBUG),)

default_host_CC = $(host_toolchain)gcc

default_host_CXX = $(host_toolchain)g++

default_host_AR = $(host_toolchain)ar

define $(package)_set_vars

$(package)_build_opts=CC="$($(package)_cc)"

$(package)_build_opts_mingw32=-f Makefile.mingw

$(package)_build_env+=CFLAGS="$($(package)_cflags) $($(package)_cppflags)" AR="$($(package)_ar)"

endef

define $(package)_preprocess_cmds

$(package)_config_opts_x86_64_linux=linux-x86_64

$(package)_config_opts_i686_linux=linux-generic32

$(package)_config_opts_arm_linux=linux-generic32

$(package)_config_opts_aarch64_linux=linux-generic64

$(package)_config_opts_mipsel_linux=linux-generic32

$(package)_config_opts_mips_linux=linux-generic32

$(package)_linux_dependencies=freetype fontconfig libxcb libX11 xproto libXext

$(package)_build_subdir=qtbase

$(package)_qt_libs=corelib network widgets gui plugins testlib

$(package)_qttranslations_file_name=qttranslations-$($(package)_suffix)

$(package)_qttranslations_sha256_hash=3a15aebd523c6d89fb97b2d3df866c94149653a26d27a00aac9b6d3020bc5a1d

patch -p1 < $($(package)_patch_dir)/pidlist_absolute.patch && \

patch -p1 < $($(package)_patch_dir)/fix-xcb-include-order.patch && \

patch -p1 < $($(package)_patch_dir)/fix_qt_pkgconfig.patch && \

echo "!host_build: QMAKE_CFLAGS += $($(package)_cflags) $($(package)_cppflags)" >> qtbase/mkspecs/common/gcc-base.conf && \

echo "!host_build: QMAKE_CXXFLAGS += $($(package)_cxxflags) $($(package)_cppflags)" >> qtbase/mkspecs/common/gcc-base.conf && \

echo "!host_build: QMAKE_LFLAGS += $($(package)_ldflags)" >> qtbase/mkspecs/common/gcc-base.conf && \

package=zeromq

$(package)_download_path=https://github.com/zeromq/libzmq/releases/download/v$($(package)_version)/

$(package)_file_name=$(package)-$($(package)_version).tar.gz

define $(package)_set_vars

$(package)_config_opts=--without-docs --disable-shared --without-libsodium --disable-curve --disable-curve-keygen --disable-perf

define $(package)_preprocess_cmds

patch -p1 < $($(package)_patch_dir)/0001-fix-build-with-older-mingw64.patch && \

endef

define $(package)_config_cmds

Working OS X DMGs are created in Linux by combining a recent clang,

the Apple binutils (ld, ar, etc) and DMG authoring tools.

* verificationprogress : (numeric) estimate of verification progress [0..1]

* chainwork : (string) total amount of work in active chain, in hexadecimal

* pruned : (boolean) if the blocks are subject to pruning

* softforks : (array) status of softforks in progress

* bip9_softforks : (object) status of BIP9 softforks in progress

Then build using:

./autogen.sh

./configure BDB_CFLAGS="-I${BDB_PREFIX}/include" BDB_LIBS="-L${BDB_PREFIX}/lib -ldb_cxx"

gmake

1. Enable the Windows Subsystem for Linux feature

* Open the Windows Features dialog (`OptionalFeatures.exe`)

* Click 'OK' and restart if necessary

2. Install Ubuntu

* Open Microsoft Store and search for Ubuntu or use [this link](https://www.microsoft.com/store/productId/9NBLGGH4MSV6)

| Qt | [5.7.1](https://download.qt.io/official_releases/qt/) | 4.7+ | No | | |

| XCB | | | | | [Yes](https://github.com/bitcoin/bitcoin/blob/master/depends/packages/qt.mk#L94) (Linux only) |

| xkbcommon | | | | | [Yes](https://github.com/bitcoin/bitcoin/blob/master/depends/packages/qt.mk#L93) (Linux only) |

| zlib | [1.2.11](http://zlib.net/) | | | | No |

Run configure with the --enable-debug option, then make. Or run configure with

CXXFLAGS="-g -ggdb -O0" or whatever debug flags you need.

**debug.log**

If the code is behaving strangely, take a look in the debug.log file in the data directory;

- DumpAddresses : Dumps IP addresses of nodes to peers.dat.

- ThreadRPCServer : Remote procedure call handler, listens on port 8332 for connections and services them.

- Shutdown : Does an orderly shutdown of everything.

Ignoring IDE/editor files

- *Rationale*: Easier to understand what is happening, thus easier to spot mistakes, even for those

that are not language lawyers

Strings and formatting

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

```c++

class AddressBookPage

{

}

AddressBookPage::AddressBookPage(Mode _mode) :

...

```

The scripted-diff is verified by the tool `contrib/devtools/commit-script-check.sh`

RPC interface guidelines

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

To test, run `systemctl start bitcoind` and to enable for system startup run

`systemctl enable bitcoind`

### OpenRC

Rename bitcoind.openrc to bitcoind and drop it in /etc/init.d. Double

### Upstart (for Debian/Ubuntu based distributions)

Drop bitcoind.conf in /etc/init. Test by running `service bitcoind start`

it will automatically start on reboot.

==============

Bitcoin Core is extensively tested on multiple operating systems using

Bitcoin Core should also work on most other Unix-like systems but is not

frequently tested on them.

Setup Gitian descriptors:

pushd ./bitcoin

export VERSION=(new version, e.g. 0.8.0)

git fetch

git checkout v${VERSION}

### Optional: Seed the Gitian sources cache and offline git repositories

pushd ./gitian-builder

make -C ../bitcoin/depends download SOURCES_PATH=`pwd`/cache/common

pushd ./gitian-builder

./bin/gbuild --num-make 2 --memory 3000 --commit bitcoin=v${VERSION} ../bitcoin/contrib/gitian-descriptors/gitian-linux.yml

mv build/out/bitcoin-*.tar.gz build/out/src/bitcoin-*.tar.gz ../

./bin/gbuild --num-make 2 --memory 3000 --commit bitcoin=v${VERSION} ../bitcoin/contrib/gitian-descriptors/gitian-win.yml

mv build/out/bitcoin-*-win-unsigned.tar.gz inputs/bitcoin-win-unsigned.tar.gz

mv build/out/bitcoin-*.zip build/out/bitcoin-*.exe ../

./bin/gbuild --num-make 2 --memory 3000 --commit bitcoin=v${VERSION} ../bitcoin/contrib/gitian-descriptors/gitian-osx.yml

mv build/out/bitcoin-*-osx-unsigned.tar.gz inputs/bitcoin-osx-unsigned.tar.gz

mv build/out/bitcoin-*.tar.gz build/out/bitcoin-*.dmg ../

popd

Commit your signature to gitian.sigs:

pushd gitian.sigs

git commit -a

git push # Assuming you can push to the gitian.sigs tree

popd

pushd ./gitian-builder

./bin/gbuild -i --commit signature=v${VERSION} ../bitcoin/contrib/gitian-descriptors/gitian-osx-signer.yml

./bin/gverify -v -d ../gitian.sigs/ -r ${VERSION}-osx-signed ../bitcoin/contrib/gitian-descriptors/gitian-osx-signer.yml

mv build/out/bitcoin-osx-signed.dmg ../bitcoin-${VERSION}-osx.dmg

popd

pushd ./gitian-builder

./bin/gbuild -i --commit signature=v${VERSION} ../bitcoin/contrib/gitian-descriptors/gitian-win-signer.yml

./bin/gverify -v -d ../gitian.sigs/ -r ${VERSION}-win-signed ../bitcoin/contrib/gitian-descriptors/gitian-win-signer.yml

mv build/out/bitcoin-*win64-setup.exe ../bitcoin-${VERSION}-win64-setup.exe

mv build/out/bitcoin-*win32-setup.exe ../bitcoin-${VERSION}-win32-setup.exe

Commit your signature for the signed OS X/Windows binaries:

pushd gitian.sigs

git commit -a

git push # Assuming you can push to the gitian.sigs tree

popd

`pip install transifex-client`

```ini

nano ~/.transifexrc

retrieve the chain from the last known block to the new tip.

There are several possibilities that ZMQ notification can get lost

using. Bitcoind appends an up-counting sequence number to each

notification which allows listeners to detect lost notifications.

DIST_SUBDIRS = secp256k1 univalue

AM_CPPFLAGS = $(HARDENED_CPPFLAGS)

EXTRA_LIBRARIES =

indirectmap.h \

init.h \

key.h \

keystore.h \

dbwrapper.h \

limitedmap.h \

rpc/protocol.h \

rpc/safemode.h \

rpc/server.h \

rpc/register.h \

rpc/util.h \

scheduler.h \

core_read.cpp \

core_write.cpp \

key.cpp \

keystore.cpp \

netaddress.cpp \

netbase.cpp \

bench/lockedpool.cpp \

bench/perf.cpp \

bench/perf.h \

nodist_bench_bench_bitcoin_SOURCES = $(GENERATED_BENCH_FILES)

TEST_BINARY=test/test_bitcoin$(EXEEXT)

JSON_TEST_FILES = \

test/data/base58_encode_decode.json \

test/data/tx_invalid.json \

RAW_TEST_FILES =

test/DoS_tests.cpp \

test/getarg_tests.cpp \

test/hash_tests.cpp \

test/key_tests.cpp \

test/limitedmap_tests.cpp \

test/dbwrapper_tests.cpp \

info.fInTried = true;

}

{

int nId;

if (nUBucket == -1)

return;

}

bool CAddrMan::Add_(const CAddress& addr, const CNetAddr& source, int64_t nTimePenalty)

int CAddrMan::RandomInt(int nMax){

return GetRandInt(nMax);

}

//! ... in at least this many days

#define ADDRMAN_MIN_FAIL_DAYS 7

//! the maximum percentage of nodes to return in a getaddr call

#define ADDRMAN_GETADDR_MAX_PCT 23

#define ADDRMAN_NEW_BUCKET_COUNT (1 << ADDRMAN_NEW_BUCKET_COUNT_LOG2)

#define ADDRMAN_BUCKET_SIZE (1 << ADDRMAN_BUCKET_SIZE_LOG2)

/**

* Stochastical (IP) address manager

*/

//! last time Good was called (memory only)

int64_t nLastGood;

protected:

//! secret key to randomize bucket select with

uint256 nKey;

void ClearNew(int nUBucket, int nUBucketPos);

//! Mark an entry "good", possibly moving it from "new" to "tried".

//! Add an entry to the "new" table.

bool Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimePenalty);

//! Select an address to connect to, if newOnly is set to true, only the new table is selected from.

CAddrInfo Select_(bool newOnly);

//! Wraps GetRandInt to allow tests to override RandomInt and make it determinismistic.

virtual int RandomInt(int nMax);

}

//! Mark an entry as accessible.

{

LOCK(cs);

Check();

Check();

}

Check();

}

/**

* Choose an address to connect to.

*/

base_uint ret;

for (int i = 0; i < WIDTH; i++)

ret.pn[i] = ~pn[i];

return ret;

}

#include <base58.h>

#include <hash.h>

#include <uint256.h>

#include <assert.h>

#include <string.h>

/** All alphanumeric characters except for "0", "I", "O", and "l" */

static const char* pszBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

{

return DecodeBase58Check(str.c_str(), vchRet);

}

#ifndef BITCOIN_BASE58_H

#define BITCOIN_BASE58_H

#include <string>

#include <vector>

* Decode a base58-encoded string (psz) that includes a checksum into a byte

* vector (vchRet), return true if decoding is successful

*/

/**

* Decode a base58-encoded string (str) that includes a checksum into a byte

* vector (vchRet), return true if decoding is successful

*/

#endif // BITCOIN_BASE58_H

LOCK(wallet.cs_wallet);

while (state.KeepRunning()) {

// Add coins.

for (int i = 0; i < 1000; i++)

addCoin(1000 * COIN, wallet, vCoins);

assert(success);

assert(nValueRet == 1003 * COIN);

assert(setCoinsRet.size() == 2);

}

}

#include <config/bitcoin-config.h>

#endif

#include <clientversion.h>

#include <coins.h>

#include <consensus/consensus.h>

#include <core_io.h>

#include <keystore.h>

#include <policy/policy.h>

#include <policy/rbf.h>

for (unsigned int kidx = 0; kidx < keysObj.size(); kidx++) {

if (!keysObj[kidx].isStr())

throw std::runtime_error("privatekey not a std::string");

throw std::runtime_error("privatekey not valid");

tempKeystore.AddKey(key);

}

// (the tx=... number in the SetBestChain debug.log lines)

3.5 // * estimated number of transactions per second after that timestamp

};

}

};

0.09

};

}

};

base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

bech32_hrp = "bcrt";

}

};

bool MineBlocksOnDemand() const { return fMineBlocksOnDemand; }

/** Return the BIP70 network string (main, test or regtest) */

std::string NetworkIDString() const { return strNetworkID; }

/** Return the list of hostnames to look up for DNS seeds */

const std::vector<std::string>& DNSSeeds() const { return vSeeds; }

const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }

bool fMineBlocksOnDemand;

CCheckpointData checkpointData;

ChainTxData chainTxData;

};

/**

#include <config/bitcoin-config.h>

#endif

#ifdef WIN32

#ifdef _WIN32_WINNT

#undef _WIN32_WINNT

#include <core_io.h>

#include <consensus/consensus.h>

#include <consensus/validation.h>

#include <script/script.h>

#include <script/standard.h>

#include <serialize.h>

/** Return the smallest number n such that (x >> n) == 0 (or 64 if the highest bit in x is set. */

uint64_t static inline CountBits(uint64_t x)

{

if (sizeof(unsigned long) >= sizeof(uint64_t)) {

return x ? 8 * sizeof(unsigned long) - __builtin_clzl(x) : 0;

}

#endif

if (sizeof(unsigned long long) >= sizeof(uint64_t)) {

return x ? 8 * sizeof(unsigned long long) - __builtin_clzll(x) : 0;

}

}

CDBWrapper::CDBWrapper(const fs::path& path, size_t nCacheSize, bool fMemory, bool fWipe, bool obfuscate)

{

penv = nullptr;

readoptions.verify_checksums = true;

bool CDBWrapper::WriteBatch(CDBBatch& batch, bool fSync)

{

leveldb::Status status = pdb->Write(fSync ? syncoptions : writeoptions, &batch.batch);

dbwrapper_private::HandleError(status);

return true;

}

// Prefixed with null character to avoid collisions with other keys

//

// We must use a string constructor which specifies length so that we copy

//! the database itself

leveldb::DB* pdb;

//! a key used for optional XOR-obfuscation of the database

std::vector<unsigned char> obfuscate_key;

bool WriteBatch(CDBBatch& batch, bool fSync = false);

// not available for LevelDB; provide for compatibility with BDB

bool Flush()

{

#include <httprpc.h>

#include <chainparams.h>

#include <httpserver.h>

#include <rpc/protocol.h>

#include <rpc/server.h>

#include <random.h>

strUsage += HelpMessageOpt("-limitdescendantcount=<n>", strprintf("Do not accept transactions if any ancestor would have <n> or more in-mempool descendants (default: %u)", DEFAULT_DESCENDANT_LIMIT));

strUsage += HelpMessageOpt("-limitdescendantsize=<n>", strprintf("Do not accept transactions if any ancestor would have more than <n> kilobytes of in-mempool descendants (default: %u).", DEFAULT_DESCENDANT_SIZE_LIMIT));

strUsage += HelpMessageOpt("-vbparams=deployment:start:end", "Use given start/end times for specified version bits deployment (regtest-only)");

}

strUsage += HelpMessageOpt("-debug=<category>", strprintf(_("Output debugging information (default: %u, supplying <category> is optional)"), 0) + ". " +

_("If <category> is not supplied or if <category> = 1, output all debugging information.") + " " + _("<category> can be:") + " " + ListLogCategories() + ".");

strUsage += HelpMessageOpt("-whitelistrelay", strprintf(_("Accept relayed transactions received from whitelisted peers even when not relaying transactions (default: %d)"), DEFAULT_WHITELISTRELAY));

strUsage += HelpMessageGroup(_("Block creation options:"));

strUsage += HelpMessageOpt("-blockmaxweight=<n>", strprintf(_("Set maximum BIP141 block weight (default: %d)"), DEFAULT_BLOCK_MAX_WEIGHT));

strUsage += HelpMessageOpt("-blockmintxfee=<amt>", strprintf(_("Set lowest fee rate (in %s/kB) for transactions to be included in block creation. (default: %s)"), CURRENCY_UNIT, FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE)));

if (showDebug)

if (gArgs.IsArgSet("-dustrelayfee"))

{

CAmount n = 0;

return InitError(AmountErrMsg("dustrelayfee", gArgs.GetArg("-dustrelayfee", "")));

dustRelayFee = CFeeRate(n);

}

status.ok()) {

if (record.size() < 12) {

reporter.Corruption(

continue;

}

WriteBatchInternal::SetContents(&batch, record);

virtual Status Close() { return Status::OK(); }

virtual Status Flush() { return Status::OK(); }

virtual Status Sync() { return Status::OK(); }

};

bool HandleDumpCommand(Env* env, char** files, int num) {

}

void Reader::ReportCorruption(uint64_t bytes, const char* reason) {

}

void Reader::ReportDrop(uint64_t bytes, const Status& reason) {

while (reader.ReadRecord(&record, &scratch)) {

if (record.size() < 12) {

reporter.Corruption(

continue;

}

WriteBatchInternal::SetContents(&batch, record);

return Status::OK();

}

private:

FileState* file_;

uint64_t pos_;

return file_->Read(offset, n, result, scratch);

}

private:

FileState* file_;

};

virtual Status Flush() { return Status::OK(); }

virtual Status Sync() { return Status::OK(); }

private:

FileState* file_;

};

// REQUIRES: External synchronization

virtual Status Skip(uint64_t n) = 0;

private:

// No copying allowed

SequentialFile(const SequentialFile&);

virtual Status Read(uint64_t offset, size_t n, Slice* result,

char* scratch) const = 0;

private:

// No copying allowed

RandomAccessFile(const RandomAccessFile&);

virtual Status Flush() = 0;

virtual Status Sync() = 0;

private:

// No copying allowed

WritableFile(const WritableFile&);

}

if (contents.size() != n + kBlockTrailerSize) {

delete[] buf;

}

// Check the crc of the type and the block contents

const uint32_t actual = crc32c::Value(data, n + 1);

if (actual != crc) {

delete[] buf;

return s;

}

}

size_t ulength = 0;

if (!port::Snappy_GetUncompressedLength(data, n, &ulength)) {

delete[] buf;

}

char* ubuf = new char[ulength];

if (!port::Snappy_Uncompress(data, n, ubuf)) {

delete[] buf;

delete[] ubuf;

}

delete[] buf;

result->data = Slice(ubuf, ulength);

}

default:

delete[] buf;

}

return Status::OK();

}

return Status::OK();

}

};

// pread() based random-access

}

return s;

}

};

// mmap() based random-access

}

return s;

}

};

class PosixWritableFile : public WritableFile {

}

return s;

}

};

static int LockOrUnlock(int fd, bool lock) {

virtual Status Read(size_t n, Slice* result, char* scratch);

virtual Status Skip(uint64_t n);

BOOL isEnable();

private:

BOOL _Init();

void _CleanUp();

virtual ~Win32RandomAccessFile();

virtual Status Read(uint64_t offset, size_t n, Slice* result,char* scratch) const;

BOOL isEnable();

private:

BOOL _Init(LPCWSTR path);

void _CleanUp();

virtual Status Flush();

virtual Status Sync();

BOOL isEnable();

private:

std::string filename_;

::HANDLE _hFile;

#include <queue>

#include <utility>

// Unconfirmed transactions in the memory pool often depend on other

// transactions in the memory pool. When we select transactions from the

// pool, we select by highest fee rate of a transaction combined with all

if (fListen && pnode->fSuccessfullyConnected)

{

CAddress addrLocal = GetLocalAddress(&pnode->addr, pnode->GetLocalServices());

// If discovery is enabled, sometimes give our peer the address it

// tells us that it sees us as in case it has a better idea of our

// address than we do.

{

addrLocal.SetIP(pnode->GetAddrLocal());

}

{

LogPrint(BCLog::NET, "AdvertiseLocal: advertising address %s\n", addrLocal.ToString());

FastRandomContext insecure_rand;

}

}

int64_t nANow = GetAdjustedTime();

int nTries = 0;

while (!interruptNet)

{

// if we selected an invalid address, restart

if (!addr.IsValid() || setConnected.count(addr.GetGroup()) || IsLocal(addr))

fOneShot = false;

m_manual_connection = false;

fClient = false; // set by version message

fFeeler = false;

fSuccessfullyConnected = false;

fDisconnect = false;

bool fOneShot;

bool m_manual_connection;

bool fClient;

const bool fInbound;

std::atomic_bool fSuccessfullyConnected;

std::atomic_bool fDisconnect;

}

}

void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid, CConnman* connman) {

AssertLockHeld(cs_main);

CNodeState* nodestate = State(nodeid);

return nEvicted;

}

void Misbehaving(NodeId pnode, int howmuch, const std::string& message)

{

if (howmuch == 0)

scheduler.scheduleEvery(std::bind(&PeerLogicValidation::CheckForStaleTipAndEvictPeers, this, consensusParams), EXTRA_PEER_CHECK_INTERVAL * 1000);

}

void PeerLogicValidation::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex, const std::vector<CTransactionRef>& vtxConflicted) {

LOCK(g_cs_orphans);

}

}

if (vOrphanErase.size()) {

int nErased = 0;

for (uint256 &orphanHash : vOrphanErase) {

static uint256 most_recent_block_hash;

static bool fWitnessesPresentInMostRecentCompactBlock;

void PeerLogicValidation::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock) {

std::shared_ptr<const CBlockHeaderAndShortTxIDs> pcmpctblock = std::make_shared<const CBlockHeaderAndShortTxIDs> (*pblock, true);

const CNetMsgMaker msgMaker(PROTOCOL_VERSION);

});

}

void PeerLogicValidation::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) {

const int nNewHeight = pindexNew->nHeight;

connman->SetBestHeight(nNewHeight);

if (!fInitialDownload) {

// Find the hashes of all blocks that weren't previously in the best chain.

std::vector<uint256> vHashes;

nTimeBestReceived = GetTime();

}

void PeerLogicValidation::BlockChecked(const CBlock& block, const CValidationState& state) {

LOCK(cs_main);

pfrom->cleanSubVer = cleanSubVer;

}

pfrom->nStartingHeight = nStartingHeight;

{

LOCK(pfrom->cs_filter);

pfrom->fRelayTxes = fRelay; // set to true after we get the first filter* message

// We only bother storing full nodes, though this may include

// things which we would not make an outbound connection to, in

// part because we may make feeler connections to them.

continue;

if (addr.nTime <= 100000000 || addr.nTime > nNow + 10 * 60)

// Message: getdata (blocks)

//

std::vector<CInv> vGetData;

std::vector<const CBlockIndex*> vToDownload;

NodeId staller = -1;

FindNextBlocksToDownload(pto->GetId(), MAX_BLOCKS_IN_TRANSIT_PER_PEER - state.nBlocksInFlight, vToDownload, staller, consensusParams);

public:

explicit PeerLogicValidation(CConnman* connman, CScheduler &scheduler);

void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected, const std::vector<CTransactionRef>& vtxConflicted) override;

void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;

void BlockChecked(const CBlock& block, const CValidationState& state) override;

void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock) override;

void InitializeNode(CNode* pnode) override;

void FinalizeNode(NodeId nodeid, bool& fUpdateConnectionTime) override;

/** Process protocol messages received from a given node */

bool ProcessMessages(CNode* pfrom, std::atomic<bool>& interrupt) override;

*/

bool SendMessages(CNode* pto, std::atomic<bool>& interrupt) override;

void ConsiderEviction(CNode *pto, int64_t time_in_seconds);

void CheckForStaleTipAndEvictPeers(const Consensus::Params &consensusParams);

void EvictExtraOutboundPeers(int64_t time_in_seconds);

private:

if (pszName[0] == 0)

return false;

int port = portDefault;

SplitHostPort(std::string(pszName), port, hostname);

std::vector<CNetAddr> vIP;

#include <stdint.h>

#include <string.h>

#include <iterator>

#include <type_traits>

#pragma pack(push, 1)

/** Implements a drop-in replacement for std::vector<T> which stores up to N

* elements directly (without heap allocation). The types Size and Diff are

T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }

const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }

public:

void assign(size_type n, const T& val) {

clear();

if (capacity() < n) {

change_capacity(n);

}

}

template<typename InputIterator>

if (capacity() < n) {

change_capacity(n);

}

}

prevector() : _size(0), _union{{}} {}

explicit prevector(size_type n, const T& val = T()) : _size(0) {

change_capacity(n);

}

template<typename InputIterator>

prevector(InputIterator first, InputIterator last) : _size(0) {

size_type n = last - first;

change_capacity(n);

}

prevector(const prevector<N, T, Size, Diff>& other) : _size(0) {

}

prevector(prevector<N, T, Size, Diff>&& other) : _size(0) {

if (&other == this) {

return *this;

}

return *this;

}

}

void resize(size_type new_size) {

erase(item_ptr(new_size), end());

}

if (new_size > capacity()) {

change_capacity(new_size);

}

}

void reserve(size_type new_capacity) {

if (capacity() < new_size) {

change_capacity(new_size + (new_size >> 1));

}

_size++;

}

void insert(iterator pos, size_type count, const T& value) {

if (capacity() < new_size) {

change_capacity(new_size + (new_size >> 1));

}

_size += count;

}

template<typename InputIterator>

if (capacity() < new_size) {

change_capacity(new_size + (new_size >> 1));

}

_size += count;

}

iterator erase(iterator pos) {

# include <arpa/inet.h>

#endif

namespace NetMsgType {

const char *VERSION="version";

const char *VERACK="verack";

}

CAddress::CAddress() : CService()

{

#include <uint256.h>

#include <version.h>

#include <stdint.h>

#include <string>

* If the NODE_NONE return value is changed, contrib/seeds/makeseeds.py

* should be updated appropriately to filter for the same nodes.

*/

/**

* A shortcut for (services & GetDesirableServiceFlags(services))

/**

* Checks if a peer with the given service flags may be capable of having a

*/

static inline bool MayHaveUsefulAddressDB(ServiceFlags services) {

}

/** A CService with information about it as peer */

#include <qt/guiutil.h>

#include <qt/walletmodel.h>

#include <wallet/wallet.h>

#include <QFont>

#include <QDebug>

#include <init.h>

#include <rpc/server.h>

#include <ui_interface.h>

#include <util.h>

#include <warnings.h>

// Declare meta types used for QMetaObject::invokeMethod

Q_DECLARE_METATYPE(bool*)

Q_DECLARE_METATYPE(CAmount)

static void InitMessage(const std::string &message)

{

#include <qt/bitcoinaddressvalidator.h>

/* Base58 characters are:

"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

showNormalIfMinimized();

QMessageBox mBox(static_cast<QMessageBox::Icon>(nMBoxIcon), strTitle, message, buttons, this);

int r = mBox.exec();

if (ret != nullptr)

*ret = r == QMessageBox::Ok;

double ClientModel::getVerificationProgress(const CBlockIndex *tipIn) const

{

CBlockIndex *tip = const_cast<CBlockIndex *>(tipIn);

if (!tip)

{

tip = chainActive.Tip();

}

return GuessVerificationProgress(Params().TxData(), tip);

#include <wallet/coincontrol.h>

#include <init.h>

#include <policy/fees.h>

#include <policy/policy.h>

#include <validation.h> // For mempool

<property name="text">

<string>Hide</string>

</property>

</widget>

</item>

</layout>

<item>

<widget class="QLabel" name="labelCustomPerKilobyte">

<property name="toolTip">

</property>

<property name="text">

<string>per kilobyte</string>

#include <qt/qvalidatedlineedit.h>

#include <qt/walletmodel.h>

#include <primitives/transaction.h>

#include <init.h>

#include <policy/policy.h>

#include <protocol.h>

bool openBitcoinConf()

{

/* Create the file */

boost::filesystem::ofstream configFile(pathConfig, std::ios_base::app);

#include <qt/paymentrequestplus.h>

#include <util.h>

#include <stdexcept>

#include <qt/paymentrequest.pb.h>

#pragma GCC diagnostic pop

#include <openssl/x509.h>

#include <qt/guiutil.h>

#include <qt/optionsmodel.h>

#include <chainparams.h>

#include <policy/policy.h>

#include <ui_interface.h>

#include <util.h>

#include <wallet/wallet.h>

<< "importmulti"

<< "signmessagewithprivkey"

<< "signrawtransaction"

<< "walletpassphrase"

<< "walletpassphrasechange"

<< "encryptwallet";

connect(model->getPeerTableModel(), SIGNAL(layoutChanged()), this, SLOT(peerLayoutChanged()));

// peer table signal handling - cache selected node ids

connect(model->getPeerTableModel(), SIGNAL(layoutAboutToBeChanged()), this, SLOT(peerLayoutAboutToChange()));

// set up ban table

ui->banlistWidget->setModel(model->getBanTableModel());

ui->banlistWidget->verticalHeader()->hide();

#else

QString clsKey = "Ctrl-L";

#endif

message(CMD_REPLY, (tr("Welcome to the %1 RPC console.").arg(tr(PACKAGE_NAME)) + "<br>" +

tr("Use up and down arrows to navigate history, and %1 to clear screen.").arg("<b>"+clsKey+"</b>") + "<br>" +

tr("Type %1 for an overview of available commands.").arg("<b>help</b>") + "<br>" +

{

if(!g_connman)

return;

// Get selected peer addresses

QList<QModelIndex> nodes = GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);

for(int i = 0; i < nodes.count(); i++)

{

if (!clientModel || !g_connman)

return;

// Get selected peer addresses

QList<QModelIndex> nodes = GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);

for(int i = 0; i < nodes.count(); i++)

#include <qt/platformstyle.h>

#include <qt/sendcoinsentry.h>

#include <chainparams.h>

#include <wallet/coincontrol.h>

#include <validation.h> // mempool and minRelayTxFee

#include <ui_interface.h>

accept();

CoinControlDialog::coinControl()->UnSelectAll();

coinControlUpdateLabels();

}

fNewRecipientAllowed = true;

}

void SendCoinsDialog::clear()

{

// Remove entries until only one left

while(ui->entries->count())

{

void setBalance(const CAmount& balance, const CAmount& unconfirmedBalance, const CAmount& immatureBalance,

const CAmount& watchOnlyBalance, const CAmount& watchUnconfBalance, const CAmount& watchImmatureBalance);

private:

Ui::SendCoinsDialog *ui;

ClientModel *clientModel;

#include <qt/platformstyle.h>

#include <qt/walletmodel.h>

#include <init.h>

#include <validation.h> // For strMessageMagic

#include <wallet/wallet.h>

#include <qt/test/paymentrequestdata.h>

#include <amount.h>

#include <random.h>

#include <script/script.h>

#include <script/standard.h>

QVERIFY(filtered == "signmessagewithprivkey(…)");

RPCConsole::RPCParseCommandLine(result, "signmessagewithprivkey abc,def", false, &filtered);

QVERIFY(filtered == "signmessagewithprivkey(…)");

RPCConsole::RPCParseCommandLine(result, "walletpassphrase(help())", false, &filtered);

QVERIFY(filtered == "walletpassphrase(…)");

RPCConsole::RPCParseCommandLine(result, "walletpassphrasechange(help(walletpassphrasechange(abc)))", false, &filtered);

#include <qt/transactiontablemodel.h>

#include <qt/transactionview.h>

#include <qt/walletmodel.h>

#include <test/test_bitcoin.h>

#include <validation.h>

#include <wallet/wallet.h>

#include <qt/paymentserver.h>

#include <qt/transactionrecord.h>

#include <consensus/consensus.h>

#include <validation.h>

#include <script/script.h>

#include <timedata.h>

#include <util.h>

#include <wallet/db.h>

#include <wallet/wallet.h>

#include <stdint.h>

#include <string>

strHTML += "<b>" + tr("Transaction ID") + ":</b> " + rec->getTxID() + "<br>";

strHTML += "<b>" + tr("Transaction total size") + ":</b> " + QString::number(wtx.tx->GetTotalSize()) + " bytes<br>";

strHTML += "<b>" + tr("Output index") + ":</b> " + QString::number(rec->getOutputIndex()) + "<br>";

// Message from normal bitcoin:URI (bitcoin:123...?message=example)

#include <qt/transactionrecord.h>

#include <consensus/consensus.h>

#include <validation.h>

#include <timedata.h>

#include <wallet/wallet.h>

void TransactionView::chooseDate(int idx)

{

QDate current = QDate::currentDate();

dateRangeWidget->setVisible(false);

switch(dateWidget->itemData(idx).toInt())

transactionView->setFocus();

}

// We override the virtual resizeEvent of the QWidget to adjust tables column

// sizes as the tables width is proportional to the dialogs width.

void TransactionView::resizeEvent(QResizeEvent* event)

#include <qt/guiutil.h>

#include <QWidget>

#include <QKeyEvent>

void changedSearch();

void exportClicked();

void focusTransaction(const QModelIndex&);

};

#endif // BITCOIN_QT_TRANSACTIONVIEW_H

#include <qt/sendcoinsdialog.h>

#include <qt/transactiontablemodel.h>

#include <chain.h>

#include <keystore.h>

#include <validation.h>

#include <net.h> // for g_connman

#ifndef BITCOIN_QT_WALLETMODEL_H

#define BITCOIN_QT_WALLETMODEL_H

#include <qt/paymentrequestplus.h>

#include <qt/walletmodeltransaction.h>

connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), transactionView, SLOT(focusTransaction(QModelIndex)));

connect(overviewPage, SIGNAL(outOfSyncWarningClicked()), this, SLOT(requestedSyncWarningInfo()));

// Double-clicking on a transaction on the transaction history page shows details

connect(transactionView, SIGNAL(doubleClicked(QModelIndex)), transactionView, SLOT(showDetails()));

// Clicking on a transaction on the overview page simply sends you to transaction history page

connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), gui, SLOT(gotoHistoryPage()));

// Receive and report messages

connect(this, SIGNAL(message(QString,QString,unsigned int)), gui, SLOT(message(QString,QString,unsigned int)));

static std::string AvailableDataFormatsString()

{

for (unsigned int i = 0; i < ARRAYLEN(rf_names); i++)

if (strlen(rf_names[i].name) > 0) {

formats.append(".");

" \"wtxid\" : hash, (string) hash of serialized transaction, including witness data\n"

" \"depends\" : [ (array) unconfirmed transactions used as inputs for this transaction\n"

" \"transactionid\", (string) parent transaction id\n"

" ... ]\n";

}

}

info.pushKV("depends", depends);

}

UniValue mempoolToJSON(bool fVerbose)

const CBlockIndex* pindex;

int blockcount = 30 * 24 * 60 * 60 / Params().GetConsensus().nPowTargetSpacing; // By default: 1 month

LOCK(cs_main);

}

}

{ "listreceivedbyaddress", 0, "minconf" },

{ "listreceivedbyaddress", 1, "include_empty" },

{ "listreceivedbyaddress", 2, "include_watchonly" },

{ "listreceivedbyaccount", 0, "minconf" },

{ "listreceivedbyaccount", 1, "include_empty" },

{ "listreceivedbyaccount", 2, "include_watchonly" },

{ "decoderawtransaction", 1, "iswitness" },

{ "signrawtransaction", 1, "prevtxs" },

{ "signrawtransaction", 2, "privkeys" },

{ "sendrawtransaction", 1, "allowhighfees" },

{ "combinerawtransaction", 0, "txs" },

{ "fundrawtransaction", 1, "options" },

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <amount.h>

#include <chain.h>

#include <chainparams.h>

#include <core_io.h>

#include <init.h>

#include <validation.h>

#include <miner.h>

#include <net.h>

#include <policy/fees.h>

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chain.h>

#include <clientversion.h>

#include <core_io.h>

#include <crypto/ripemd160.h>

#include <init.h>

#include <validation.h>

#include <httpserver.h>

#include <net.h>

"\nCreates a multi-signature address with n signature of m keys required.\n"

"It returns a json object with the address and redeemScript.\n"

"\nArguments:\n"

"2. \"keys\" (string, required) A json array of hex-encoded public keys\n"

" [\n"

" \"key\" (string) The hex-encoded public key\n"

std::string strPrivkey = request.params[0].get_str();

std::string strMessage = request.params[1].get_str();

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");

CHashWriter ss(SER_GETHASH, 0);

ss << strMessageMagic;

" \"pingtime\": n, (numeric) ping time (if available)\n"

" \"minping\": n, (numeric) minimum observed ping time (if any at all)\n"

" \"pingwait\": n, (numeric) ping wait (if non-zero)\n"

" \"subver\": \"/Satoshi:0.8.5/\", (string) The string version\n"

" \"inbound\": true|false, (boolean) Inbound (true) or Outbound (false)\n"

" \"addnode\": true|false, (boolean) Whether connection was due to addnode/-connect or if it was an automatic/inbound connection\n"

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chain.h>

#include <coins.h>

#include <consensus/validation.h>

#include <keystore.h>

#include <validation.h>

#include <validationinterface.h>

#include <merkleblock.h>

#include <net.h>

#include <policy/policy.h>

#include <policy/rbf.h>

#include <primitives/transaction.h>

#include <rpc/safemode.h>

#include <rpc/server.h>

#include <script/script.h>

#include <utilstrencodings.h>

#ifdef ENABLE_WALLET

#include <wallet/rpcwallet.h>

#endif

#include <future>

return EncodeHexTx(mergedTx);

}

{

// Fetch previous transactions (inputs):

CCoinsView viewDummy;

CCoinsViewCache view(&viewDummy);

{

CCoinsViewCache &viewChain = *pcoinsTip;

CCoinsViewMemPool viewMempool(&viewChain, mempool);

view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view

view.SetBackend(viewDummy); // switch back to avoid locking mempool for too long

}

// Add previous txouts given in the RPC call:

const UniValue& p = prevTxs[idx];

throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "expected object with {\"txid'\",\"vout\",\"scriptPubKey\"}");

UniValue prevOut = p.get_obj();

uint256 txid = ParseHashO(prevOut, "txid");

int nOut = find_value(prevOut, "vout").get_int();

throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "vout must be positive");

COutPoint out(txid, nOut);

std::vector<unsigned char> pkData(ParseHexO(prevOut, "scriptPubKey"));

}

// if redeemScript given and not using the local wallet (private keys

RPCTypeCheckObj(prevOut,

{

{"txid", UniValueType(UniValue::VSTR)},

if (!v.isNull()) {

std::vector<unsigned char> rsData(ParseHexV(v, "redeemScript"));

CScript redeemScript(rsData.begin(), rsData.end());

// Automatically also add the P2WSH wrapped version of the script (to deal with P2SH-P2WSH).

}

}

}

}

int nHashType = SIGHASH_ALL;

static std::map<std::string, int> mapSigHashValues = {

{std::string("ALL"), int(SIGHASH_ALL)},

{std::string("ALL|ANYONECANPAY"), int(SIGHASH_ALL|SIGHASH_ANYONECANPAY)},

{std::string("SINGLE"), int(SIGHASH_SINGLE)},

{std::string("SINGLE|ANYONECANPAY"), int(SIGHASH_SINGLE|SIGHASH_ANYONECANPAY)},

};

nHashType = mapSigHashValues[strHashType];

throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid sighash param");

}

bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE);

SignatureData sigdata;

// Only sign SIGHASH_SINGLE if there's a corresponding output:

sigdata = CombineSignatures(prevPubKey, TransactionSignatureChecker(&txConst, i, amount), sigdata, DataFromTransaction(mtx, i));

UpdateTransaction(mtx, i, sigdata);

return result;

}

UniValue sendrawtransaction(const JSONRPCRequest& request)

{

if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)

}

static const CRPCCommand commands[] =

};

void RegisterRawTransactionRPCCommands(CRPCTable &t)

#include <rpc/server.h>

#include <fs.h>

#include <init.h>

#include <random.h>

#include <sync.h>

#include <ui_interface.h>

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <keystore.h>

#include <pubkey.h>

#include <rpc/protocol.h>

bool ProduceSignature(const BaseSignatureCreator& creator, const CScript& fromPubKey, SignatureData& sigdata)

{

std::vector<valtype> result;

txnouttype whichType;

bool P2SH = false;

CScript subscript;

sigdata.scriptWitness.stack.clear();

// Solver returns the subscript that needs to be evaluated;

// the final scriptSig is the signatures from that

// and then the serialized subscript:

P2SH = true;

}

{

CAddrMan::Delete(nId);

}

};

static CNetAddr ResolveIP(const char* ip)

BOOST_CHECK_EQUAL(addrman.size(), 0);

for (unsigned int i = 1; i < 18; i++) {

addrman.Add(CAddress(addr, NODE_NONE), source);

//Test: No collision in new table yet.

BOOST_CHECK_EQUAL(addrman.size(), 0);

for (unsigned int i = 1; i < 80; i++) {

addrman.Add(CAddress(addr, NODE_NONE), source);

addrman.Good(CAddress(addr, NODE_NONE));

for (unsigned int i = 1; i < (8 * 256); i++) {

int octet1 = i % 256;

int octet2 = i >> 8 % 256;

CAddress addr = CAddress(ResolveService(strAddr), NODE_NONE);

// Ensure that for all addrs in addrman, isTerrible == false.

std::set<int> buckets;

for (int i = 0; i < 255; i++) {

CAddrInfo infoi = CAddrInfo(

int bucket = infoi.GetTriedBucket(nKey1);

buckets.insert(bucket);

}

buckets.clear();

for (int j = 0; j < 255; j++) {

CAddrInfo infoj = CAddrInfo(

int bucket = infoj.GetTriedBucket(nKey1);

buckets.insert(bucket);

}

std::set<int> buckets;

for (int i = 0; i < 255; i++) {

CAddrInfo infoi = CAddrInfo(

int bucket = infoi.GetNewBucket(nKey1);

buckets.insert(bucket);

}

for (int j = 0; j < 4 * 255; j++) {

CAddrInfo infoj = CAddrInfo(CAddress(

ResolveService(

ResolveIP("251.4.1.1"));

int bucket = infoj.GetNewBucket(nKey1);

buckets.insert(bucket);

for (int p = 0; p < 255; p++) {

CAddrInfo infoj = CAddrInfo(

CAddress(ResolveService("250.1.1.1"), NODE_NONE),

int bucket = infoj.GetNewBucket(nKey1);

buckets.insert(bucket);

}

// than 64 buckets.

BOOST_CHECK(buckets.size() > 64);

}

BOOST_AUTO_TEST_SUITE_END()

for (unsigned int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)

{

std::string strEnc = EncodeBase32(vstrIn[i]);

std::string strDec = DecodeBase32(vstrOut[i]);

}

}

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <test/data/base58_encode_decode.json.h>

#include <test/test_bitcoin.h>

#include <utilstrencodings.h>

#include <univalue.h>

BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());

}

BOOST_AUTO_TEST_SUITE_END()

for (unsigned int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)

{

std::string strEnc = EncodeBase64(vstrIn[i]);

std::string strDec = DecodeBase64(strEnc);

}

}

#include <boost/test/unit_test.hpp>

#include <key.h>

#include <uint256.h>

#include <util.h>

#include <utilstrencodings.h>

pubkey.Encode(data);

// Test private key

// Test public key

// Derive new keys

CExtKey keyNew;

#include <bloom.h>

#include <clientversion.h>

#include <key.h>

#include <merkleblock.h>

#include <primitives/block.h>

#include <random.h>

BOOST_AUTO_TEST_CASE(bloom_create_insert_key)

{

std::string strSecret = std::string("5Kg1gnAjaLfKiwhhPpGS3QfRg2m6awQvaj98JCZBZQ5SuS2F15C");

CPubKey pubkey = key.GetPubKey();

std::vector<unsigned char> vchPubKey(pubkey.begin(), pubkey.end());

boost::thread_group tg;

std::mutex m;

std::condition_variable cv;

{

std::unique_lock<std::mutex> l(m);

tg.create_thread([&]{

CCheckQueueControl<FakeCheck> control(queue.get());

[[["9628667ad48219a169b41b020800162287d2c0f713c04157e95c484a8dcb7592", 7500, "0x00 0x20 0x9b66c15b4e0b4eb49fa877982cafded24859fe5b0e2dbfbe4f0df1de7743fd52", 200000]],

"010000000001019275cb8d4a485ce95741c013f7c0d28722160008021bb469a11982d47a6628964c1d000000ffffffff0101000000000000000007004830450220487fb382c4974de3f7d834c1b617fe15860828c7f96454490edd6d891556dcc9022100baf95feb48f845d5bfc9882eb6aeefa1bc3790e39f59eaa46ff7f15ae626c53e0148304502205286f726690b2e9b0207f0345711e63fa7012045b9eb0f19c2458ce1db90cf43022100e89f17f86abc5b149eba4115d4f128bcf45d77fb3ecdd34f594091340c0395960101022102966f109c54e85d3aee8321301136cedeb9fc710fdef58a9de8a73942f8e567c021034ffc99dd9a79dd3cb31e2ab3e0b09e0e67db41ac068c625cd1f491576016c84e9552af4830450220487fb382c4974de3f7d834c1b617fe15860828c7f96454490edd6d891556dcc9022100baf95feb48f845d5bfc9882eb6aeefa1bc3790e39f59eaa46ff7f15ae626c53e0148304502205286f726690b2e9b0207f0345711e63fa7012045b9eb0f19c2458ce1db90cf43022100e89f17f86abc5b149eba4115d4f128bcf45d77fb3ecdd34f594091340c039596017500000000", "P2SH,WITNESS"],

["Make diffs cleaner by leaving a comment here without comma at the end"]

]