Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-2021 The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <compressor.h>
7 : :
8 : : #include <pubkey.h>
9 : : #include <script/script.h>
10 : :
11 : : /*
12 : : * These check for scripts for which a special case with a shorter encoding is defined.
13 : : * They are implemented separately from the CScript test, as these test for exact byte
14 : : * sequence correspondences, and are more strict. For example, IsToPubKey also verifies
15 : : * whether the public key is valid (as invalid ones cannot be represented in compressed
16 : : * form).
17 : : */
18 : :
19 : 2703897 : static bool IsToKeyID(const CScript& script, CKeyID &hash)
20 : : {
21 [ + + + - : 3434840 : if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160
+ + + - +
+ ]
22 [ + - + + : 715270 : && script[2] == 20 && script[23] == OP_EQUALVERIFY
+ - + + ]
23 [ + + + - : 3173565 : && script[24] == OP_CHECKSIG) {
+ + ]
24 [ + - ]: 459936 : memcpy(&hash, &script[3], 20);
25 : 229968 : return true;
26 : : }
27 : : return false;
28 : : }
29 : :
30 : 2473929 : static bool IsToScriptID(const CScript& script, CScriptID &hash)
31 : : {
32 [ + + + - : 2533111 : if (script.size() == 23 && script[0] == OP_HASH160 && script[1] == 20
+ + + - +
+ ]
33 [ + + + - : 2507835 : && script[22] == OP_EQUAL) {
+ + ]
34 [ + - ]: 30996 : memcpy(&hash, &script[2], 20);
35 : 15498 : return true;
36 : : }
37 : : return false;
38 : : }
39 : :
40 : 2458431 : static bool IsToPubKey(const CScript& script, CPubKey &pubkey)
41 : : {
42 [ + + + + : 2485121 : if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG
+ + ]
43 [ + + + + : 145413 : && (script[1] == 0x02 || script[1] == 0x03)) {
+ + ]
44 : 21598 : pubkey.Set(&script[1], &script[34]);
45 : 21598 : return true;
46 : : }
47 [ + + + + : 2454937 : if (script.size() == 67 && script[0] == 65 && script[66] == OP_CHECKSIG
+ + ]
48 [ + + + + ]: 114596 : && script[1] == 0x04) {
49 : 11886 : pubkey.Set(&script[1], &script[66]);
50 : 11886 : return pubkey.IsFullyValid(); // if not fully valid, a case that would not be compressible
51 : : }
52 : : return false;
53 : : }
54 : :
55 : 2703897 : bool CompressScript(const CScript& script, CompressedScript& out)
56 : : {
57 : 2703897 : CKeyID keyID;
58 [ + + ]: 2703897 : if (IsToKeyID(script, keyID)) {
59 : 229968 : out.resize(21);
60 [ + - ]: 229968 : out[0] = 0x00;
61 [ + - ]: 459936 : memcpy(&out[1], &keyID, 20);
62 : 229968 : return true;
63 : : }
64 : 2473929 : CScriptID scriptID;
65 [ + + ]: 2473929 : if (IsToScriptID(script, scriptID)) {
66 : 15498 : out.resize(21);
67 [ + - ]: 15498 : out[0] = 0x01;
68 [ + - ]: 30996 : memcpy(&out[1], &scriptID, 20);
69 : 15498 : return true;
70 : : }
71 : 2458431 : CPubKey pubkey;
72 [ + + ]: 2458431 : if (IsToPubKey(script, pubkey)) {
73 : 31612 : out.resize(33);
74 [ + - + + ]: 63224 : memcpy(&out[1], &pubkey[1], 32);
75 [ + + + + ]: 31612 : if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {
76 [ + - ]: 21598 : out[0] = pubkey[0];
77 : 21598 : return true;
78 [ + - ]: 10014 : } else if (pubkey[0] == 0x04) {
79 [ + - ]: 10014 : out[0] = 0x04 | (pubkey[64] & 0x01);
80 : 10014 : return true;
81 : : }
82 : : }
83 : : return false;
84 : : }
85 : :
86 : 395716 : unsigned int GetSpecialScriptSize(unsigned int nSize)
87 : : {
88 [ + + ]: 395716 : if (nSize == 0 || nSize == 1)
89 : : return 20;
90 [ + + ]: 78744 : if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5)
91 : 78670 : return 32;
92 : : return 0;
93 : : }
94 : :
95 : 395559 : bool DecompressScript(CScript& script, unsigned int nSize, const CompressedScript& in)
96 : : {
97 [ + + + + : 395559 : switch(nSize) {
+ ]
98 : 289896 : case 0x00:
99 : 289896 : script.resize(25);
100 [ + - ]: 289896 : script[0] = OP_DUP;
101 [ + - ]: 289896 : script[1] = OP_HASH160;
102 [ + - ]: 289896 : script[2] = 20;
103 [ + + + - : 869688 : memcpy(&script[3], in.data(), 20);
+ - ]
104 [ + - ]: 289896 : script[23] = OP_EQUALVERIFY;
105 [ + - ]: 289896 : script[24] = OP_CHECKSIG;
106 : 289896 : return true;
107 : 26959 : case 0x01:
108 : 26959 : script.resize(23);
109 [ + - ]: 26959 : script[0] = OP_HASH160;
110 [ + - ]: 26959 : script[1] = 20;
111 [ + + + - : 80877 : memcpy(&script[2], in.data(), 20);
+ - ]
112 [ + - ]: 26959 : script[22] = OP_EQUAL;
113 : 26959 : return true;
114 : 28309 : case 0x02:
115 : 28309 : case 0x03:
116 : 28309 : script.resize(35);
117 [ - + ]: 28309 : script[0] = 33;
118 [ - + ]: 28309 : script[1] = nSize;
119 [ + + - + : 84927 : memcpy(&script[2], in.data(), 32);
- + ]
120 [ - + ]: 28309 : script[34] = OP_CHECKSIG;
121 : 28309 : return true;
122 : 50323 : case 0x04:
123 : 50323 : case 0x05:
124 : 50323 : unsigned char vch[33] = {};
125 : 50323 : vch[0] = nSize - 2;
126 [ + + ]: 100646 : memcpy(&vch[1], in.data(), 32);
127 : 50323 : CPubKey pubkey{vch};
128 [ + + ]: 50323 : if (!pubkey.Decompress())
129 : : return false;
130 [ - + ]: 22583 : assert(pubkey.size() == 65);
131 : 22583 : script.resize(67);
132 [ - + ]: 22583 : script[0] = 65;
133 [ - + - + ]: 45166 : memcpy(&script[1], pubkey.begin(), 65);
134 [ - + ]: 22583 : script[66] = OP_CHECKSIG;
135 : 22583 : return true;
136 : : }
137 : : return false;
138 : : }
139 : :
140 : : // Amount compression:
141 : : // * If the amount is 0, output 0
142 : : // * first, divide the amount (in base units) by the largest power of 10 possible; call the exponent e (e is max 9)
143 : : // * if e<9, the last digit of the resulting number cannot be 0; store it as d, and drop it (divide by 10)
144 : : // * call the result n
145 : : // * output 1 + 10*(9*n + d - 1) + e
146 : : // * if e==9, we only know the resulting number is not zero, so output 1 + 10*(n - 1) + 9
147 : : // (this is decodable, as d is in [1-9] and e is in [0-9])
148 : :
149 : 2703107 : uint64_t CompressAmount(uint64_t n)
150 : : {
151 [ + + ]: 2703107 : if (n == 0)
152 : : return 0;
153 : : int e = 0;
154 [ + + + + ]: 9338376 : while (((n % 10) == 0) && e < 9) {
155 : 7814437 : n /= 10;
156 : 7814437 : e++;
157 : : }
158 [ + + ]: 1523939 : if (e < 9) {
159 : 1095412 : int d = (n % 10);
160 [ - + ]: 1095412 : assert(d >= 1 && d <= 9);
161 : 1095412 : n /= 10;
162 : 1095412 : return 1 + (n*9 + d - 1)*10 + e;
163 : : } else {
164 : 428527 : return 1 + (n - 1)*10 + 9;
165 : : }
166 : : }
167 : :
168 : 10521678 : uint64_t DecompressAmount(uint64_t x)
169 : : {
170 : : // x = 0 OR x = 1+10*(9*n + d - 1) + e OR x = 1+10*(n - 1) + 9
171 [ + + ]: 10521678 : if (x == 0)
172 : : return 0;
173 : 8658340 : x--;
174 : : // x = 10*(9*n + d - 1) + e
175 : 8658340 : int e = x % 10;
176 : 8658340 : x /= 10;
177 : 8658340 : uint64_t n = 0;
178 [ + + ]: 8658340 : if (e < 9) {
179 : : // x = 9*n + d - 1
180 : 2558319 : int d = (x % 9) + 1;
181 : 2558319 : x /= 9;
182 : : // x = n
183 : 2558319 : n = x*10 + d;
184 : : } else {
185 : 6100021 : n = x+1;
186 : : }
187 [ + + ]: 74668150 : while (e) {
188 : 66009810 : n *= 10;
189 : 66009810 : e--;
190 : : }
191 : : return n;
192 : : }
|
