mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 20:12:57 +01:00
346ae84acf
83a425d25af033086744c1c8c892015014ed46bd compressor: use a prevector in compressed script serialization (William Casarin)
Pull request description:
This function was doing millions of unnecessary heap allocations during IBD.
I'm start to catalog unnecessary heap allocations as a pet project of mine: as-zero-as-possible-alloc IBD. This is one small step.
before:
![May01-174536](https://user-images.githubusercontent.com/45598/80850964-9a38de80-8bd3-11ea-8eec-08cd38ee1fa1.png)
after:
![May01-174610](https://user-images.githubusercontent.com/45598/80850974-a91f9100-8bd3-11ea-94a1-e2077391f6f4.png)
~should I type alias this?~ *I type aliased it*
This is a part of the Zero Allocations Project #18849 (ZAP1). This code came up as a place where many allocations occur.
ACKs for top commit:
Empact:
ACK 83a425d25a
elichai:
tACK 83a425d25af033086744c1c8c892015014ed46bd
sipa:
utACK 83a425d25af033086744c1c8c892015014ed46bd
Tree-SHA512: f0ffa6ab0ea1632715b0b76362753f9f6935f05cdcc80d85566774401155a3c57ad45a687942a1806d3503858f0bb698da9243746c8e2edb8fdf13611235b0e0
193 lines
5.3 KiB
C++
193 lines
5.3 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <compressor.h>
|
|
|
|
#include <pubkey.h>
|
|
#include <script/standard.h>
|
|
|
|
/*
|
|
* These check for scripts for which a special case with a shorter encoding is defined.
|
|
* They are implemented separately from the CScript test, as these test for exact byte
|
|
* sequence correspondences, and are more strict. For example, IsToPubKey also verifies
|
|
* whether the public key is valid (as invalid ones cannot be represented in compressed
|
|
* form).
|
|
*/
|
|
|
|
static bool IsToKeyID(const CScript& script, CKeyID &hash)
|
|
{
|
|
if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160
|
|
&& script[2] == 20 && script[23] == OP_EQUALVERIFY
|
|
&& script[24] == OP_CHECKSIG) {
|
|
memcpy(&hash, &script[3], 20);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool IsToScriptID(const CScript& script, CScriptID &hash)
|
|
{
|
|
if (script.size() == 23 && script[0] == OP_HASH160 && script[1] == 20
|
|
&& script[22] == OP_EQUAL) {
|
|
memcpy(&hash, &script[2], 20);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool IsToPubKey(const CScript& script, CPubKey &pubkey)
|
|
{
|
|
if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG
|
|
&& (script[1] == 0x02 || script[1] == 0x03)) {
|
|
pubkey.Set(&script[1], &script[34]);
|
|
return true;
|
|
}
|
|
if (script.size() == 67 && script[0] == 65 && script[66] == OP_CHECKSIG
|
|
&& script[1] == 0x04) {
|
|
pubkey.Set(&script[1], &script[66]);
|
|
return pubkey.IsFullyValid(); // if not fully valid, a case that would not be compressible
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CompressScript(const CScript& script, CompressedScript& out)
|
|
{
|
|
CKeyID keyID;
|
|
if (IsToKeyID(script, keyID)) {
|
|
out.resize(21);
|
|
out[0] = 0x00;
|
|
memcpy(&out[1], &keyID, 20);
|
|
return true;
|
|
}
|
|
CScriptID scriptID;
|
|
if (IsToScriptID(script, scriptID)) {
|
|
out.resize(21);
|
|
out[0] = 0x01;
|
|
memcpy(&out[1], &scriptID, 20);
|
|
return true;
|
|
}
|
|
CPubKey pubkey;
|
|
if (IsToPubKey(script, pubkey)) {
|
|
out.resize(33);
|
|
memcpy(&out[1], &pubkey[1], 32);
|
|
if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {
|
|
out[0] = pubkey[0];
|
|
return true;
|
|
} else if (pubkey[0] == 0x04) {
|
|
out[0] = 0x04 | (pubkey[64] & 0x01);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
unsigned int GetSpecialScriptSize(unsigned int nSize)
|
|
{
|
|
if (nSize == 0 || nSize == 1)
|
|
return 20;
|
|
if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5)
|
|
return 32;
|
|
return 0;
|
|
}
|
|
|
|
bool DecompressScript(CScript& script, unsigned int nSize, const CompressedScript& in)
|
|
{
|
|
switch(nSize) {
|
|
case 0x00:
|
|
script.resize(25);
|
|
script[0] = OP_DUP;
|
|
script[1] = OP_HASH160;
|
|
script[2] = 20;
|
|
memcpy(&script[3], in.data(), 20);
|
|
script[23] = OP_EQUALVERIFY;
|
|
script[24] = OP_CHECKSIG;
|
|
return true;
|
|
case 0x01:
|
|
script.resize(23);
|
|
script[0] = OP_HASH160;
|
|
script[1] = 20;
|
|
memcpy(&script[2], in.data(), 20);
|
|
script[22] = OP_EQUAL;
|
|
return true;
|
|
case 0x02:
|
|
case 0x03:
|
|
script.resize(35);
|
|
script[0] = 33;
|
|
script[1] = nSize;
|
|
memcpy(&script[2], in.data(), 32);
|
|
script[34] = OP_CHECKSIG;
|
|
return true;
|
|
case 0x04:
|
|
case 0x05:
|
|
unsigned char vch[33] = {};
|
|
vch[0] = nSize - 2;
|
|
memcpy(&vch[1], in.data(), 32);
|
|
CPubKey pubkey(&vch[0], &vch[33]);
|
|
if (!pubkey.Decompress())
|
|
return false;
|
|
assert(pubkey.size() == 65);
|
|
script.resize(67);
|
|
script[0] = 65;
|
|
memcpy(&script[1], pubkey.begin(), 65);
|
|
script[66] = OP_CHECKSIG;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Amount compression:
|
|
// * If the amount is 0, output 0
|
|
// * first, divide the amount (in base units) by the largest power of 10 possible; call the exponent e (e is max 9)
|
|
// * if e<9, the last digit of the resulting number cannot be 0; store it as d, and drop it (divide by 10)
|
|
// * call the result n
|
|
// * output 1 + 10*(9*n + d - 1) + e
|
|
// * if e==9, we only know the resulting number is not zero, so output 1 + 10*(n - 1) + 9
|
|
// (this is decodable, as d is in [1-9] and e is in [0-9])
|
|
|
|
uint64_t CompressAmount(uint64_t n)
|
|
{
|
|
if (n == 0)
|
|
return 0;
|
|
int e = 0;
|
|
while (((n % 10) == 0) && e < 9) {
|
|
n /= 10;
|
|
e++;
|
|
}
|
|
if (e < 9) {
|
|
int d = (n % 10);
|
|
assert(d >= 1 && d <= 9);
|
|
n /= 10;
|
|
return 1 + (n*9 + d - 1)*10 + e;
|
|
} else {
|
|
return 1 + (n - 1)*10 + 9;
|
|
}
|
|
}
|
|
|
|
uint64_t DecompressAmount(uint64_t x)
|
|
{
|
|
// x = 0 OR x = 1+10*(9*n + d - 1) + e OR x = 1+10*(n - 1) + 9
|
|
if (x == 0)
|
|
return 0;
|
|
x--;
|
|
// x = 10*(9*n + d - 1) + e
|
|
int e = x % 10;
|
|
x /= 10;
|
|
uint64_t n = 0;
|
|
if (e < 9) {
|
|
// x = 9*n + d - 1
|
|
int d = (x % 9) + 1;
|
|
x /= 9;
|
|
// x = n
|
|
n = x*10 + d;
|
|
} else {
|
|
n = x+1;
|
|
}
|
|
while (e) {
|
|
n *= 10;
|
|
e--;
|
|
}
|
|
return n;
|
|
}
|