├── README.md
├── bootstrap.sh
├── footer.md
├── header.md
├── linearize-data.py
├── linearize-hashes.py
├── linearize-mainnet.cfg
├── linearize-testnet.cfg
├── links-mainnet.md
└── links-testnet.md


/README.md:
--------------------------------------------------------------------------------
 1 | # bootstrap.dat files for [Dash Core](https://github.com/dashpay/dash)
 2 | 
 3 | ### Usage
 4 | 
 5 | 1. Download and extract one of the recent files linked below.
 6 | 1. Run your wallet with `-loadblock=/path/to/bootstrap.dat` command line option and let it sync.
 7 | 1. Once sync is done `bootstrap.dat` file is no longer needed and can be removed.
 8 | 
 9 | ### Recent files
10 | 
11 | #### For mainnet:
12 | 
13 | Block [2280843](https://insight.dash.org/insight/block/0000000000000025650024ef8c75d0dafcddb72f5350cae8c5a56b2da9d01566): Sun Jun  1 03:00:01 AM UTC 2025 [zip](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/mainnet/2025-06-01/bootstrap.dat.zip) (28G) [SHA256](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/mainnet/2025-06-01/sha256.txt)
14 | 
15 | Block [2264304](https://insight.dash.org/insight/block/0000000000000016028934ffe627b1c628255cf83241528be8979b6e16bd4936): Thu May  1 11:07:53 PM UTC 2025 [zip](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/mainnet/2025-05-01/bootstrap.dat.zip) (28G) [SHA256](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/mainnet/2025-05-01/sha256.txt)
16 | 
17 | 
18 | #### For testnet:
19 | 
20 | Block [1261825](https://insight.testnet.networks.dash.org/insight/block/000000b9ce6d0fb4346c8df29007df5931037ec5fb1c9ef788f640dbc9a06c50): Sun Jun  1 03:31:44 AM UTC 2025 [zip](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/testnet/2025-06-01/bootstrap.dat.zip) (2.1G) [SHA256](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/testnet/2025-06-01/sha256.txt)
21 | 
22 | Block [1243163](https://insight.testnet.networks.dash.org/insight/block/000000cca5a7883f7d08a58087d2883bc7e47d1fc2222d11959ab9a2282d59ee): Thu May  1 11:38:44 PM UTC 2025 [zip](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/testnet/2025-05-01/bootstrap.dat.zip) (2.1G) [SHA256](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/testnet/2025-05-01/sha256.txt)
23 | 
24 | 
25 | ### Donations are welcome:
26 | 
27 | DASH: XsV4GHVKGTjQFvwB7c6mYsGV3Mxf7iser6
28 | 


--------------------------------------------------------------------------------
/bootstrap.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | s3cmd="/usr/local/bin/s3cmd --config=/root/.s3cfg"
 3 | s3name="dash-bootstrap-2"
 4 | s3bucket="s3://$s3name/"
 5 | s3https="https://$s3name.ams3.digitaloceanspaces.com/"
 6 | file="bootstrap.dat"
 7 | file_zip="$file.zip"
 8 | file_sha256="sha256.txt"
 9 | header=`cat header.md`
10 | footer=`cat footer.md`
11 | 
12 | # pass network name as a param
13 | do_the_job() {
14 |   network=$1
15 |   date=`date -u`
16 |   date_fmt=`date -u +%Y-%m-%d`
17 |   s3networkPath="$s3bucket$network/"
18 |   s3currentPath="$s3networkPath$date_fmt/"
19 |   s3currentUrl="$s3https$network/$date_fmt/"
20 |   linksFile="links-$network.md"
21 |   prevLinks=`head -n1 $linksFile`
22 |   echo "$network job - Starting..."
23 |   # process blockchain
24 |   ./linearize-hashes.py linearize-$network.cfg > hashlist.txt
25 |   ./linearize-data.py linearize-$network.cfg
26 |   # compress
27 |   zip $file_zip $file
28 |   # calculate checksums
29 |   sha256sum $file > $file_sha256
30 |   sha256sum $file_zip >> $file_sha256
31 |   # store
32 |   $s3cmd put $file_zip $file_sha256 $s3currentPath --acl-public
33 |   # update docs
34 |   url_zip=$s3currentUrl$file_zip
35 |   url_sha256=$s3currentUrl$file_sha256
36 |   size_zip=`ls -lh $file_zip | awk -F" " '{ print $5 }'`
37 |   newLinks="Block [$blocks]($url_explorer): $date [zip]($url_zip) ($size_zip) [SHA256]($url_sha256)\n\n$prevLinks"
38 |   echo -e "$newLinks" > $linksFile
39 |   rm $file $file_zip $file_sha256 hashlist.txt
40 |   echo -e "#### For $network:\n\n$newLinks\n\n" >> README.md
41 |   # clean up old files
42 |   keepDays=55
43 |   scanDays=80
44 |   oldFolders=$($s3cmd ls $s3networkPath | grep -oP 's3:.*')
45 |   while [ $keepDays -lt $scanDays ]; do
46 |     loopDate=$(date -u -d "now -"$keepDays" days" +%Y-%m-%d)
47 |     found=$(echo -e $oldFolders | grep -oP $loopDate)
48 |     if [ "$found" != "" ]; then
49 |       echo "found old folder $found, deleting $s3networkPath$loopDate/ ..."
50 |       $s3cmd del -r $s3networkPath$loopDate/
51 |     fi
52 |     let keepDays=keepDays+1
53 |   done
54 |   echo "$network job - Done!"
55 | }
56 | 
57 | # fill the header
58 | echo -e "$header\n" > README.md
59 | 
60 | # mainnet
61 | #cat ~/.dash/blocks/blk0000* > $file
62 | blocks=`dash-cli getblockcount`
63 | blockhash=`dash-cli getblockhash $blocks`
64 | url_explorer="https://insight.dash.org/insight/block/$blockhash"
65 | do_the_job mainnet
66 | 
67 | # testnet
68 | #cat ~/.dash/testnet3/blocks/blk0000* > $file
69 | blocks=`dash_testnet-cli -datadir=/root/.dashcore_test getblockcount`
70 | blockhash=`dash_testnet-cli -datadir=/root/.dashcore_test getblockhash $blocks`
71 | url_explorer="https://insight.testnet.networks.dash.org/insight/block/$blockhash"
72 | do_the_job testnet
73 | 
74 | # finalize with the footer
75 | echo -e "$footer" >> README.md
76 | 
77 | # push to github
78 | git add *.md
79 | git commit -m "$date - autoupdate"
80 | git push
81 | 


--------------------------------------------------------------------------------
/footer.md:
--------------------------------------------------------------------------------
1 | ### Donations are welcome:
2 | 
3 | DASH: XsV4GHVKGTjQFvwB7c6mYsGV3Mxf7iser6
4 | 


--------------------------------------------------------------------------------
/header.md:
--------------------------------------------------------------------------------
 1 | # bootstrap.dat files for [Dash Core](https://github.com/dashpay/dash)
 2 | 
 3 | ### Usage
 4 | 
 5 | 1. Download and extract one of the recent files linked below.
 6 | 1. Run your wallet with `-loadblock=/path/to/bootstrap.dat` command line option and let it sync.
 7 | 1. Once sync is done `bootstrap.dat` file is no longer needed and can be removed.
 8 | 
 9 | ### Recent files
10 | 


--------------------------------------------------------------------------------
/linearize-data.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | #
  3 | # linearize-data.py: Construct a linear, no-fork version of the chain.
  4 | #
  5 | # Copyright (c) 2013-2014 The Bitcoin Core developers
  6 | # Distributed under the MIT software license, see the accompanying
  7 | # file COPYING or http://www.opensource.org/licenses/mit-license.php.
  8 | #
  9 | 
 10 | import struct
 11 | import re
 12 | import os
 13 | import os.path
 14 | import sys
 15 | import dash_hash
 16 | import datetime
 17 | import time
 18 | import glob
 19 | from collections import namedtuple
 20 | from binascii import unhexlify
 21 | 
 22 | settings = {}
 23 | 
 24 | def hex_switchEndian(s):
 25 |     """ Switches the endianness of a hex string (in pairs of hex chars) """
 26 |     pairList = [s[i:i+2].encode() for i in range(0, len(s), 2)]
 27 |     return b''.join(pairList[::-1]).decode()
 28 | 
 29 | def uint32(x):
 30 |     return x & 0xffffffff
 31 | 
 32 | def bytereverse(x):
 33 |     return uint32(( ((x) << 24) | (((x) << 8) & 0x00ff0000) |
 34 |                (((x) >> 8) & 0x0000ff00) | ((x) >> 24) ))
 35 | 
 36 | def bufreverse(in_buf):
 37 |     out_words = []
 38 |     for i in range(0, len(in_buf), 4):
 39 |         word = struct.unpack('@I', in_buf[i:i+4])[0]
 40 |         out_words.append(struct.pack('@I', bytereverse(word)))
 41 |     return b''.join(out_words)
 42 | 
 43 | def wordreverse(in_buf):
 44 |     out_words = []
 45 |     for i in range(0, len(in_buf), 4):
 46 |         out_words.append(in_buf[i:i+4])
 47 |     out_words.reverse()
 48 |     return b''.join(out_words)
 49 | 
 50 | def calc_hdr_hash(blk_hdr):
 51 |     #hash1 = hashlib.sha256()
 52 |     #hash1.update(blk_hdr)
 53 |     #hash1_o = hash1.digest()
 54 | 
 55 |     #hash2 = hashlib.sha256()
 56 |     #hash2.update(hash1_o)
 57 |     #hash2_o = hash2.digest()
 58 | 
 59 |     #return hash2_o
 60 |         pow_hash = dash_hash.getPoWHash(blk_hdr)
 61 |         return pow_hash
 62 | 
 63 | def calc_hash_str(blk_hdr):
 64 |     hash = calc_hdr_hash(blk_hdr)
 65 |     hash = bufreverse(hash)
 66 |     hash = wordreverse(hash)
 67 |     hash_str = hash.hex()
 68 |     return hash_str
 69 | 
 70 | def get_blk_dt(blk_hdr):
 71 |     members = struct.unpack("<I", blk_hdr[68:68+4])
 72 |     nTime = members[0]
 73 |     dt = datetime.datetime.fromtimestamp(nTime)
 74 |     dt_ym = datetime.datetime(dt.year, dt.month, 1)
 75 |     return (dt_ym, nTime)
 76 | 
 77 | # When getting the list of block hashes, undo any byte reversals.
 78 | def get_block_hashes(settings):
 79 |     blkindex = []
 80 |     f = open(settings['hashlist'], "r", encoding="utf8")
 81 |     for line in f:
 82 |         line = line.rstrip()
 83 |         if settings['rev_hash_bytes'] == 'true':
 84 |             line = hex_switchEndian(line)
 85 |         blkindex.append(line)
 86 | 
 87 |     print("Read " + str(len(blkindex)) + " hashes")
 88 | 
 89 |     return blkindex
 90 | 
 91 | # The block map shouldn't give or receive byte-reversed hashes.
 92 | def mkblockmap(blkindex):
 93 |     blkmap = {}
 94 |     for height,hash in enumerate(blkindex):
 95 |         blkmap[hash] = height
 96 |     return blkmap
 97 | 
 98 | # This gets the first block file ID that exists from the input block
 99 | # file directory.
100 | def getFirstBlockFileId(block_dir_path):
101 |     # First, this sets up a pattern to search for block files, for
102 |     # example 'blkNNNNN.dat'.
103 |     blkFilePattern = os.path.join(block_dir_path, "blk[0-9][0-9][0-9][0-9][0-9].dat")
104 | 
105 |     # This search is done with glob
106 |     blkFnList = glob.glob(blkFilePattern)
107 | 
108 |     if len(blkFnList) == 0:
109 |         print("blocks not pruned - starting at 0")
110 |         return 0
111 |     # We then get the lexicographic minimum, which should be the first
112 |     # block file name.
113 |     firstBlkFilePath = min(blkFnList)
114 |     firstBlkFn = os.path.basename(firstBlkFilePath)
115 | 
116 |     # now, the string should be ['b','l','k','N','N','N','N','N','.','d','a','t']
117 |     # So get the ID by choosing:              3   4   5   6   7
118 |     # The ID is not necessarily 0 if this is a pruned node.
119 |     blkId = int(firstBlkFn[3:8])
120 |     return blkId
121 | 
122 | # Block header and extent on disk
123 | BlockExtent = namedtuple('BlockExtent', ['fn', 'offset', 'inhdr', 'blkhdr', 'size'])
124 | 
125 | class BlockDataCopier:
126 |     def __init__(self, settings, blkindex, blkmap):
127 |         self.settings = settings
128 |         self.blkindex = blkindex
129 |         self.blkmap = blkmap
130 | 
131 |         # Get first occurring block file id - for pruned nodes this
132 |         # will not necessarily be 0
133 |         self.inFn = getFirstBlockFileId(self.settings['input'])
134 |         self.inF = None
135 |         self.outFn = 0
136 |         self.outsz = 0
137 |         self.outF = None
138 |         self.outFname = None
139 |         self.blkCountIn = 0
140 |         self.blkCountOut = 0
141 | 
142 |         self.lastDate = datetime.datetime(2000, 1, 1)
143 |         self.highTS = 1408893517 - 315360000
144 |         self.timestampSplit = False
145 |         self.fileOutput = True
146 |         self.setFileTime = False
147 |         self.maxOutSz = settings['max_out_sz']
148 |         if 'output' in settings:
149 |             self.fileOutput = False
150 |         if settings['file_timestamp'] != 0:
151 |             self.setFileTime = True
152 |         if settings['split_timestamp'] != 0:
153 |             self.timestampSplit = True
154 |         # Extents and cache for out-of-order blocks
155 |         self.blockExtents = {}
156 |         self.outOfOrderData = {}
157 |         self.outOfOrderSize = 0 # running total size for items in outOfOrderData
158 | 
159 |     def writeBlock(self, inhdr, blk_hdr, rawblock):
160 |         blockSizeOnDisk = len(inhdr) + len(blk_hdr) + len(rawblock)
161 |         if not self.fileOutput and ((self.outsz + blockSizeOnDisk) > self.maxOutSz):
162 |             self.outF.close()
163 |             if self.setFileTime:
164 |                 os.utime(self.outFname, (int(time.time()), self.highTS))
165 |             self.outF = None
166 |             self.outFname = None
167 |             self.outFn = self.outFn + 1
168 |             self.outsz = 0
169 | 
170 |         (blkDate, blkTS) = get_blk_dt(blk_hdr)
171 |         if self.timestampSplit and (blkDate > self.lastDate):
172 |             print("New month " + blkDate.strftime("%Y-%m") + " @ " + self.hash_str)
173 |             self.lastDate = blkDate
174 |             if self.outF:
175 |                 self.outF.close()
176 |                 if self.setFileTime:
177 |                     os.utime(self.outFname, (int(time.time()), self.highTS))
178 |                 self.outF = None
179 |                 self.outFname = None
180 |                 self.outFn = self.outFn + 1
181 |                 self.outsz = 0
182 | 
183 |         if not self.outF:
184 |             if self.fileOutput:
185 |                 self.outFname = self.settings['output_file']
186 |             else:
187 |                 self.outFname = os.path.join(self.settings['output'], "blk%05d.dat" % self.outFn)
188 |             print("Output file " + self.outFname)
189 |             self.outF = open(self.outFname, "wb")
190 | 
191 |         self.outF.write(inhdr)
192 |         self.outF.write(blk_hdr)
193 |         self.outF.write(rawblock)
194 |         self.outsz = self.outsz + len(inhdr) + len(blk_hdr) + len(rawblock)
195 | 
196 |         self.blkCountOut = self.blkCountOut + 1
197 |         if blkTS > self.highTS:
198 |             self.highTS = blkTS
199 | 
200 |         if (self.blkCountOut % 1000) == 0:
201 |             print('%i blocks scanned, %i blocks written (of %i, %.1f%% complete)' %
202 |                     (self.blkCountIn, self.blkCountOut, len(self.blkindex), 100.0 * self.blkCountOut / len(self.blkindex)))
203 | 
204 |     def inFileName(self, fn):
205 |         return os.path.join(self.settings['input'], "blk%05d.dat" % fn)
206 | 
207 |     def fetchBlock(self, extent):
208 |         '''Fetch block contents from disk given extents'''
209 |         with open(self.inFileName(extent.fn), "rb") as f:
210 |             f.seek(extent.offset)
211 |             return f.read(extent.size)
212 | 
213 |     def copyOneBlock(self):
214 |         '''Find the next block to be written in the input, and copy it to the output.'''
215 |         extent = self.blockExtents.pop(self.blkCountOut)
216 |         if self.blkCountOut in self.outOfOrderData:
217 |             # If the data is cached, use it from memory and remove from the cache
218 |             rawblock = self.outOfOrderData.pop(self.blkCountOut)
219 |             self.outOfOrderSize -= len(rawblock)
220 |         else: # Otherwise look up data on disk
221 |             rawblock = self.fetchBlock(extent)
222 | 
223 |         self.writeBlock(extent.inhdr, extent.blkhdr, rawblock)
224 | 
225 |     def run(self):
226 |         while self.blkCountOut < len(self.blkindex):
227 |             if not self.inF:
228 |                 fname = self.inFileName(self.inFn)
229 |                 print("Input file " + fname)
230 |                 try:
231 |                     self.inF = open(fname, "rb")
232 |                 except IOError:
233 |                     print("Premature end of block data")
234 |                     return
235 | 
236 |             inhdr = self.inF.read(8)
237 |             if (not inhdr or (inhdr[0] == "\0")):
238 |                 self.inF.close()
239 |                 self.inF = None
240 |                 self.inFn = self.inFn + 1
241 |                 continue
242 | 
243 |             inMagic = inhdr[:4]
244 |             if (inMagic != self.settings['netmagic']):
245 |                 # Seek backwards 7 bytes (skipping the first byte in the previous search)
246 |                 # and continue searching from the new position if the magic bytes are not
247 |                 # found.
248 |                 self.inF.seek(-7, os.SEEK_CUR)
249 |                 continue
250 |             inLenLE = inhdr[4:]
251 |             su = struct.unpack("<I", inLenLE)
252 |             inLen = su[0] - 80 # length without header
253 |             blk_hdr = self.inF.read(80)
254 |             inExtent = BlockExtent(self.inFn, self.inF.tell(), inhdr, blk_hdr, inLen)
255 | 
256 |             self.hash_str = calc_hash_str(blk_hdr)
257 |             if not self.hash_str in blkmap:
258 |                 # Because blocks can be written to files out-of-order as of 0.10, the script
259 |                 # may encounter blocks it doesn't know about. Treat as debug output.
260 |                 if settings['debug_output'] == 'true':
261 |                     print("Skipping unknown block " + self.hash_str)
262 |                 self.inF.seek(inLen, os.SEEK_CUR)
263 |                 continue
264 | 
265 |             blkHeight = self.blkmap[self.hash_str]
266 |             self.blkCountIn += 1
267 | 
268 |             if self.blkCountOut == blkHeight:
269 |                 # If in-order block, just copy
270 |                 rawblock = self.inF.read(inLen)
271 |                 self.writeBlock(inhdr, blk_hdr, rawblock)
272 | 
273 |                 # See if we can catch up to prior out-of-order blocks
274 |                 while self.blkCountOut in self.blockExtents:
275 |                     self.copyOneBlock()
276 | 
277 |             else: # If out-of-order, skip over block data for now
278 |                 self.blockExtents[blkHeight] = inExtent
279 |                 if self.outOfOrderSize < self.settings['out_of_order_cache_sz']:
280 |                     # If there is space in the cache, read the data
281 |                     # Reading the data in file sequence instead of seeking and fetching it later is preferred,
282 |                     # but we don't want to fill up memory
283 |                     self.outOfOrderData[blkHeight] = self.inF.read(inLen)
284 |                     self.outOfOrderSize += inLen
285 |                 else: # If no space in cache, seek forward
286 |                     self.inF.seek(inLen, os.SEEK_CUR)
287 | 
288 |         print("Done (%i blocks written)" % (self.blkCountOut))
289 | 
290 | if __name__ == '__main__':
291 |     if len(sys.argv) != 2:
292 |         print("Usage: linearize-data.py CONFIG-FILE")
293 |         sys.exit(1)
294 | 
295 |     f = open(sys.argv[1], encoding="utf8")
296 |     for line in f:
297 |         # skip comment lines
298 |         m = re.search(r'^\s*#', line)
299 |         if m:
300 |             continue
301 | 
302 |         # parse key=value lines
303 |         m = re.search(r'^(\w+)\s*=\s*(\S.*)$', line)
304 |         if m is None:
305 |             continue
306 |         settings[m.group(1)] = m.group(2)
307 |     f.close()
308 | 
309 |     # Force hash byte format setting to be lowercase to make comparisons easier.
310 |     # Also place upfront in case any settings need to know about it.
311 |     if 'rev_hash_bytes' not in settings:
312 |         settings['rev_hash_bytes'] = 'false'
313 |     settings['rev_hash_bytes'] = settings['rev_hash_bytes'].lower()
314 | 
315 |     if 'netmagic' not in settings:
316 |         settings['netmagic'] = 'bf0c6bbd'
317 |     if 'genesis' not in settings:
318 |         settings['genesis'] = '00000ffd590b1485b3caadc19b22e6379c733355108f107a430458cdf3407ab6'
319 |     if 'input' not in settings:
320 |         settings['input'] = 'input'
321 |     if 'hashlist' not in settings:
322 |         settings['hashlist'] = 'hashlist.txt'
323 |     if 'file_timestamp' not in settings:
324 |         settings['file_timestamp'] = 0
325 |     if 'split_timestamp' not in settings:
326 |         settings['split_timestamp'] = 0
327 |     if 'max_out_sz' not in settings:
328 |         settings['max_out_sz'] = 1000 * 1000 * 1000
329 |     if 'out_of_order_cache_sz' not in settings:
330 |         settings['out_of_order_cache_sz'] = 100 * 1000 * 1000
331 |     if 'debug_output' not in settings:
332 |         settings['debug_output'] = 'false'
333 | 
334 |     settings['max_out_sz'] = int(settings['max_out_sz'])
335 |     settings['split_timestamp'] = int(settings['split_timestamp'])
336 |     settings['file_timestamp'] = int(settings['file_timestamp'])
337 |     settings['netmagic'] = unhexlify(settings['netmagic'].encode('utf-8'))
338 |     settings['out_of_order_cache_sz'] = int(settings['out_of_order_cache_sz'])
339 |     settings['debug_output'] = settings['debug_output'].lower()
340 | 
341 |     if 'output_file' not in settings and 'output' not in settings:
342 |         print("Missing output file / directory")
343 |         sys.exit(1)
344 | 
345 |     blkindex = get_block_hashes(settings)
346 |     blkmap = mkblockmap(blkindex)
347 | 
348 |     # Block hash map won't be byte-reversed. Neither should the genesis hash.
349 |     if not settings['genesis'] in blkmap:
350 |         print("Genesis block not found in hashlist")
351 |     else:
352 |         BlockDataCopier(settings, blkindex, blkmap).run()
353 | 


--------------------------------------------------------------------------------
/linearize-hashes.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | #
  3 | # linearize-hashes.py:  List blocks in a linear, no-fork version of the chain.
  4 | #
  5 | # Copyright (c) 2013-2014 The Bitcoin Core developers
  6 | # Distributed under the MIT software license, see the accompanying
  7 | # file COPYING or http://www.opensource.org/licenses/mit-license.php.
  8 | #
  9 | 
 10 | from http.client import HTTPConnection
 11 | import json
 12 | import re
 13 | import base64
 14 | import sys
 15 | import os
 16 | import os.path
 17 | 
 18 | settings = {}
 19 | 
 20 | def hex_switchEndian(s):
 21 |     """ Switches the endianness of a hex string (in pairs of hex chars) """
 22 |     pairList = [s[i:i+2].encode() for i in range(0, len(s), 2)]
 23 |     return b''.join(pairList[::-1]).decode()
 24 | 
 25 | class BitcoinRPC:
 26 |     def __init__(self, host, port, username, password):
 27 |         authpair = "%s:%s" % (username, password)
 28 |         authpair = authpair.encode('utf-8')
 29 |         self.authhdr = b"Basic " + base64.b64encode(authpair)
 30 |         self.conn = HTTPConnection(host, port=port, timeout=30)
 31 | 
 32 |     def execute(self, obj):
 33 |         try:
 34 |             self.conn.request('POST', '/', json.dumps(obj),
 35 |                 { 'Authorization' : self.authhdr,
 36 |                   'Content-type' : 'application/json' })
 37 |         except ConnectionRefusedError:
 38 |             print('RPC connection refused. Check RPC settings and the server status.',
 39 |                   file=sys.stderr)
 40 |             return None
 41 | 
 42 |         resp = self.conn.getresponse()
 43 |         if resp is None:
 44 |             print("JSON-RPC: no response", file=sys.stderr)
 45 |             return None
 46 | 
 47 |         body = resp.read().decode('utf-8')
 48 |         resp_obj = json.loads(body)
 49 |         return resp_obj
 50 | 
 51 |     @staticmethod
 52 |     def build_request(idx, method, params):
 53 |         obj = { 'version' : '1.1',
 54 |             'method' : method,
 55 |             'id' : idx }
 56 |         if params is None:
 57 |             obj['params'] = []
 58 |         else:
 59 |             obj['params'] = params
 60 |         return obj
 61 | 
 62 |     @staticmethod
 63 |     def response_is_error(resp_obj):
 64 |         return 'error' in resp_obj and resp_obj['error'] is not None
 65 | 
 66 | def get_block_hashes(settings, max_blocks_per_call=10000):
 67 |     rpc = BitcoinRPC(settings['host'], settings['port'],
 68 |              settings['rpcuser'], settings['rpcpassword'])
 69 | 
 70 |     height = settings['min_height']
 71 |     while height < settings['max_height']+1:
 72 |         num_blocks = min(settings['max_height']+1-height, max_blocks_per_call)
 73 |         batch = []
 74 |         for x in range(num_blocks):
 75 |             batch.append(rpc.build_request(x, 'getblockhash', [height + x]))
 76 | 
 77 |         reply = rpc.execute(batch)
 78 |         if reply is None:
 79 |             print('Cannot continue. Program will halt.')
 80 |             return None
 81 | 
 82 |         for x,resp_obj in enumerate(reply):
 83 |             if rpc.response_is_error(resp_obj):
 84 |                 print('JSON-RPC: error at height', height+x, ': ', resp_obj['error'], file=sys.stderr)
 85 |                 sys.exit(1)
 86 |             assert(resp_obj['id'] == x) # assume replies are in-sequence
 87 |             if settings['rev_hash_bytes'] == 'true':
 88 |                 resp_obj['result'] = hex_switchEndian(resp_obj['result'])
 89 |             print(resp_obj['result'])
 90 | 
 91 |         height += num_blocks
 92 | 
 93 | def get_rpc_cookie():
 94 |     # Open the cookie file
 95 |     with open(os.path.join(os.path.expanduser(settings['datadir']), '.cookie'), 'r', encoding="ascii") as f:
 96 |         combined = f.readline()
 97 |         combined_split = combined.split(":")
 98 |         settings['rpcuser'] = combined_split[0]
 99 |         settings['rpcpassword'] = combined_split[1]
100 | 
101 | if __name__ == '__main__':
102 |     if len(sys.argv) != 2:
103 |         print("Usage: linearize-hashes.py CONFIG-FILE")
104 |         sys.exit(1)
105 | 
106 |     f = open(sys.argv[1], encoding="utf8")
107 |     for line in f:
108 |         # skip comment lines
109 |         m = re.search(r'^\s*#', line)
110 |         if m:
111 |             continue
112 | 
113 |         # parse key=value lines
114 |         m = re.search(r'^(\w+)\s*=\s*(\S.*)$', line)
115 |         if m is None:
116 |             continue
117 |         settings[m.group(1)] = m.group(2)
118 |     f.close()
119 | 
120 |     if 'host' not in settings:
121 |         settings['host'] = '127.0.0.1'
122 |     if 'port' not in settings:
123 |         settings['port'] = 9998
124 |     if 'min_height' not in settings:
125 |         settings['min_height'] = 0
126 |     if 'max_height' not in settings:
127 |         settings['max_height'] = 313000
128 |     if 'rev_hash_bytes' not in settings:
129 |         settings['rev_hash_bytes'] = 'false'
130 | 
131 |     use_userpass = True
132 |     use_datadir = False
133 |     if 'rpcuser' not in settings or 'rpcpassword' not in settings:
134 |         use_userpass = False
135 |     if 'datadir' in settings and not use_userpass:
136 |         use_datadir = True
137 |     if not use_userpass and not use_datadir:
138 |         print("Missing datadir or username and/or password in cfg file", file=sys.stderr)
139 |         sys.exit(1)
140 | 
141 |     settings['port'] = int(settings['port'])
142 |     settings['min_height'] = int(settings['min_height'])
143 |     settings['max_height'] = int(settings['max_height'])
144 | 
145 |     # Force hash byte format setting to be lowercase to make comparisons easier.
146 |     settings['rev_hash_bytes'] = settings['rev_hash_bytes'].lower()
147 | 
148 |     # Get the rpc user and pass from the cookie if the datadir is set
149 |     if use_datadir:
150 |         get_rpc_cookie()
151 | 
152 |     get_block_hashes(settings)
153 | 


--------------------------------------------------------------------------------
/linearize-mainnet.cfg:
--------------------------------------------------------------------------------
 1 | # bitcoind RPC settings (linearize-hashes)
 2 | rpcuser=user
 3 | rpcpassword=password
 4 | host=127.0.0.1
 5 | port=9998
 6 | 
 7 | # bootstrap.dat hashlist settings (linearize-hashes)
 8 | max_height=3130000
 9 | 
10 | # bootstrap.dat input/output settings (linearize-data)
11 | netmagic=bf0c6bbd
12 | input=/root/.dashcore/blocks
13 | output_file=bootstrap.dat
14 | hashlist=hashlist.txt
15 | #split_year=1
16 | genesis=00000ffd590b1485b3caadc19b22e6379c733355108f107a430458cdf3407ab6
17 | 
18 | # Maxmimum size in bytes of out-of-order blocks cache in memory
19 | out_of_order_cache_sz = 10000000
20 | 


--------------------------------------------------------------------------------
/linearize-testnet.cfg:
--------------------------------------------------------------------------------
 1 | # bitcoind RPC settings (linearize-hashes)
 2 | rpcuser=user
 3 | rpcpassword=password
 4 | host=127.0.0.1
 5 | port=19998
 6 | 
 7 | # bootstrap.dat hashlist settings (linearize-hashes)
 8 | max_height=3130000
 9 | 
10 | # bootstrap.dat input/output settings (linearize-data)
11 | netmagic=cee2caff
12 | input=/root/.dashcore_test/testnet3/blocks
13 | output_file=bootstrap.dat
14 | hashlist=hashlist.txt
15 | #split_year=1
16 | genesis=00000bafbc94add76cb75e2ec92894837288a481e5c005f6563d91623bf8bc2c
17 | 
18 | # Maxmimum size in bytes of out-of-order blocks cache in memory
19 | out_of_order_cache_sz = 10000000
20 | 


--------------------------------------------------------------------------------
/links-mainnet.md:
--------------------------------------------------------------------------------
1 | Block [2280843](https://insight.dash.org/insight/block/0000000000000025650024ef8c75d0dafcddb72f5350cae8c5a56b2da9d01566): Sun Jun  1 03:00:01 AM UTC 2025 [zip](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/mainnet/2025-06-01/bootstrap.dat.zip) (28G) [SHA256](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/mainnet/2025-06-01/sha256.txt)
2 | 
3 | Block [2264304](https://insight.dash.org/insight/block/0000000000000016028934ffe627b1c628255cf83241528be8979b6e16bd4936): Thu May  1 11:07:53 PM UTC 2025 [zip](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/mainnet/2025-05-01/bootstrap.dat.zip) (28G) [SHA256](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/mainnet/2025-05-01/sha256.txt)
4 | 


--------------------------------------------------------------------------------
/links-testnet.md:
--------------------------------------------------------------------------------
1 | Block [1261825](https://insight.testnet.networks.dash.org/insight/block/000000b9ce6d0fb4346c8df29007df5931037ec5fb1c9ef788f640dbc9a06c50): Sun Jun  1 03:31:44 AM UTC 2025 [zip](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/testnet/2025-06-01/bootstrap.dat.zip) (2.1G) [SHA256](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/testnet/2025-06-01/sha256.txt)
2 | 
3 | Block [1243163](https://insight.testnet.networks.dash.org/insight/block/000000cca5a7883f7d08a58087d2883bc7e47d1fc2222d11959ab9a2282d59ee): Thu May  1 11:38:44 PM UTC 2025 [zip](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/testnet/2025-05-01/bootstrap.dat.zip) (2.1G) [SHA256](https://dash-bootstrap-2.ams3.digitaloceanspaces.com/testnet/2025-05-01/sha256.txt)
4 | 


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