tecnovert
1 year ago
committed by
GitHub
commit
4d8d421de6
30 changed files with 5926 additions and 244 deletions
@ -1,3 +1,3 @@ |
|||||||
name = "basicswap" |
name = "basicswap" |
||||||
|
|
||||||
__version__ = "0.11.66" |
__version__ = "0.11.68" |
||||||
|
|||||||
@ -0,0 +1,175 @@ |
|||||||
|
|
||||||
|
""" |
||||||
|
Copyright 2011 Jeff Garzik |
||||||
|
|
||||||
|
AuthServiceProxy has the following improvements over python-jsonrpc's |
||||||
|
ServiceProxy class: |
||||||
|
|
||||||
|
- HTTP connections persist for the life of the AuthServiceProxy object |
||||||
|
(if server supports HTTP/1.1) |
||||||
|
- sends protocol 'version', per JSON-RPC 1.1 |
||||||
|
- sends proper, incrementing 'id' |
||||||
|
- sends Basic HTTP authentication headers |
||||||
|
- parses all JSON numbers that look like floats as Decimal |
||||||
|
- uses standard Python json lib |
||||||
|
|
||||||
|
Previous copyright, from python-jsonrpc/jsonrpc/proxy.py: |
||||||
|
|
||||||
|
Copyright (c) 2007 Jan-Klaas Kollhof |
||||||
|
|
||||||
|
This file is part of jsonrpc. |
||||||
|
|
||||||
|
jsonrpc is free software; you can redistribute it and/or modify |
||||||
|
it under the terms of the GNU Lesser General Public License as published by |
||||||
|
the Free Software Foundation; either version 2.1 of the License, or |
||||||
|
(at your option) any later version. |
||||||
|
|
||||||
|
This software is distributed in the hope that it will be useful, |
||||||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
GNU Lesser General Public License for more details. |
||||||
|
|
||||||
|
You should have received a copy of the GNU Lesser General Public License |
||||||
|
along with this software; if not, write to the Free Software |
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
||||||
|
""" |
||||||
|
|
||||||
|
try: |
||||||
|
import http.client as httplib |
||||||
|
except ImportError: |
||||||
|
import httplib |
||||||
|
import base64 |
||||||
|
import decimal |
||||||
|
import json |
||||||
|
import logging |
||||||
|
try: |
||||||
|
import urllib.parse as urlparse |
||||||
|
except ImportError: |
||||||
|
import urlparse |
||||||
|
|
||||||
|
USER_AGENT = "AuthServiceProxy/0.1" |
||||||
|
|
||||||
|
HTTP_TIMEOUT = 30 |
||||||
|
|
||||||
|
log = logging.getLogger("NavcoinRPC") |
||||||
|
|
||||||
|
class JSONRPCException(Exception): |
||||||
|
def __init__(self, rpc_error): |
||||||
|
Exception.__init__(self) |
||||||
|
self.error = rpc_error |
||||||
|
|
||||||
|
|
||||||
|
def EncodeDecimal(o): |
||||||
|
if isinstance(o, decimal.Decimal): |
||||||
|
return str(o) |
||||||
|
raise TypeError(repr(o) + " is not JSON serializable") |
||||||
|
|
||||||
|
class AuthServiceProxy(object): |
||||||
|
__id_count = 0 |
||||||
|
|
||||||
|
# ensure_ascii: escape unicode as \uXXXX, passed to json.dumps |
||||||
|
def __init__(self, service_url, service_name=None, timeout=HTTP_TIMEOUT, connection=None, ensure_ascii=True): |
||||||
|
self.__service_url = service_url |
||||||
|
self._service_name = service_name |
||||||
|
self.ensure_ascii = ensure_ascii # can be toggled on the fly by tests |
||||||
|
self.__url = urlparse.urlparse(service_url) |
||||||
|
if self.__url.port is None: |
||||||
|
port = 80 |
||||||
|
else: |
||||||
|
port = self.__url.port |
||||||
|
(user, passwd) = (self.__url.username, self.__url.password) |
||||||
|
try: |
||||||
|
user = user.encode('utf8') |
||||||
|
except AttributeError: |
||||||
|
pass |
||||||
|
try: |
||||||
|
passwd = passwd.encode('utf8') |
||||||
|
except AttributeError: |
||||||
|
pass |
||||||
|
authpair = user + b':' + passwd |
||||||
|
self.__auth_header = b'Basic ' + base64.b64encode(authpair) |
||||||
|
|
||||||
|
if connection: |
||||||
|
# Callables re-use the connection of the original proxy |
||||||
|
self.__conn = connection |
||||||
|
elif self.__url.scheme == 'https': |
||||||
|
self.__conn = httplib.HTTPSConnection(self.__url.hostname, port, |
||||||
|
timeout=timeout) |
||||||
|
else: |
||||||
|
self.__conn = httplib.HTTPConnection(self.__url.hostname, port, |
||||||
|
timeout=timeout) |
||||||
|
|
||||||
|
def __getattr__(self, name): |
||||||
|
if name.startswith('__') and name.endswith('__'): |
||||||
|
# Python internal stuff |
||||||
|
raise AttributeError |
||||||
|
if self._service_name is not None: |
||||||
|
name = "%s.%s" % (self._service_name, name) |
||||||
|
return AuthServiceProxy(self.__service_url, name, connection=self.__conn) |
||||||
|
|
||||||
|
def _request(self, method, path, postdata): |
||||||
|
''' |
||||||
|
Do a HTTP request, with retry if we get disconnected (e.g. due to a timeout). |
||||||
|
This is a workaround for https://bugs.python.org/issue3566 which is fixed in Python 3.5. |
||||||
|
''' |
||||||
|
headers = {'Host': self.__url.hostname, |
||||||
|
'User-Agent': USER_AGENT, |
||||||
|
'Authorization': self.__auth_header, |
||||||
|
'Content-type': 'application/json'} |
||||||
|
try: |
||||||
|
self.__conn.request(method, path, postdata, headers) |
||||||
|
return self._get_response() |
||||||
|
except httplib.BadStatusLine as e: |
||||||
|
if e.line == "''": # if connection was closed, try again |
||||||
|
self.__conn.close() |
||||||
|
self.__conn.request(method, path, postdata, headers) |
||||||
|
return self._get_response() |
||||||
|
else: |
||||||
|
raise |
||||||
|
except BrokenPipeError: |
||||||
|
# Python 3.5+ raises this instead of BadStatusLine when the connection was reset |
||||||
|
self.__conn.close() |
||||||
|
self.__conn.request(method, path, postdata, headers) |
||||||
|
return self._get_response() |
||||||
|
|
||||||
|
def __call__(self, *args): |
||||||
|
AuthServiceProxy.__id_count += 1 |
||||||
|
|
||||||
|
log.debug("-%s-> %s %s"%(AuthServiceProxy.__id_count, self._service_name, |
||||||
|
json.dumps(args, default=EncodeDecimal, ensure_ascii=self.ensure_ascii))) |
||||||
|
postdata = json.dumps({'version': '1.1', |
||||||
|
'method': self._service_name, |
||||||
|
'params': args, |
||||||
|
'id': AuthServiceProxy.__id_count}, default=EncodeDecimal, ensure_ascii=self.ensure_ascii) |
||||||
|
response = self._request('POST', self.__url.path, postdata.encode('utf-8')) |
||||||
|
if response['error'] is not None: |
||||||
|
raise JSONRPCException(response['error']) |
||||||
|
elif 'result' not in response: |
||||||
|
raise JSONRPCException({ |
||||||
|
'code': -343, 'message': 'missing JSON-RPC result'}) |
||||||
|
else: |
||||||
|
return response['result'] |
||||||
|
|
||||||
|
def _batch(self, rpc_call_list): |
||||||
|
postdata = json.dumps(list(rpc_call_list), default=EncodeDecimal, ensure_ascii=self.ensure_ascii) |
||||||
|
log.debug("--> "+postdata) |
||||||
|
return self._request('POST', self.__url.path, postdata.encode('utf-8')) |
||||||
|
|
||||||
|
def _get_response(self): |
||||||
|
http_response = self.__conn.getresponse() |
||||||
|
if http_response is None: |
||||||
|
raise JSONRPCException({ |
||||||
|
'code': -342, 'message': 'missing HTTP response from server'}) |
||||||
|
|
||||||
|
content_type = http_response.getheader('Content-Type') |
||||||
|
if content_type != 'application/json': |
||||||
|
raise JSONRPCException({ |
||||||
|
'code': -342, 'message': 'non-JSON HTTP response with \'%i %s\' from server' % (http_response.status, http_response.reason)}) |
||||||
|
|
||||||
|
responsedata = http_response.read().decode('utf8') |
||||||
|
response = json.loads(responsedata, parse_float=decimal.Decimal) |
||||||
|
if "error" in response and response["error"] is None: |
||||||
|
log.debug("<-%s- %s"%(response["id"], json.dumps(response["result"], default=EncodeDecimal, ensure_ascii=self.ensure_ascii))) |
||||||
|
else: |
||||||
|
log.debug("<-- "+responsedata) |
||||||
|
return response |
||||||
@ -0,0 +1,101 @@ |
|||||||
|
#!/usr/bin/env python3 |
||||||
|
# |
||||||
|
# bignum.py |
||||||
|
# |
||||||
|
# This file is copied from python-navcoinlib. |
||||||
|
# |
||||||
|
# Distributed under the MIT software license, see the accompanying |
||||||
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||||
|
# |
||||||
|
|
||||||
|
"""Bignum routines""" |
||||||
|
|
||||||
|
|
||||||
|
import struct |
||||||
|
|
||||||
|
|
||||||
|
# generic big endian MPI format |
||||||
|
|
||||||
|
def bn_bytes(v, have_ext=False): |
||||||
|
ext = 0 |
||||||
|
if have_ext: |
||||||
|
ext = 1 |
||||||
|
return ((v.bit_length()+7)//8) + ext |
||||||
|
|
||||||
|
def bn2bin(v): |
||||||
|
s = bytearray() |
||||||
|
i = bn_bytes(v) |
||||||
|
while i > 0: |
||||||
|
s.append((v >> ((i-1) * 8)) & 0xff) |
||||||
|
i -= 1 |
||||||
|
return s |
||||||
|
|
||||||
|
def bin2bn(s): |
||||||
|
l = 0 |
||||||
|
for ch in s: |
||||||
|
l = (l << 8) | ch |
||||||
|
return l |
||||||
|
|
||||||
|
def bn2mpi(v): |
||||||
|
have_ext = False |
||||||
|
if v.bit_length() > 0: |
||||||
|
have_ext = (v.bit_length() & 0x07) == 0 |
||||||
|
|
||||||
|
neg = False |
||||||
|
if v < 0: |
||||||
|
neg = True |
||||||
|
v = -v |
||||||
|
|
||||||
|
s = struct.pack(b">I", bn_bytes(v, have_ext)) |
||||||
|
ext = bytearray() |
||||||
|
if have_ext: |
||||||
|
ext.append(0) |
||||||
|
v_bin = bn2bin(v) |
||||||
|
if neg: |
||||||
|
if have_ext: |
||||||
|
ext[0] |= 0x80 |
||||||
|
else: |
||||||
|
v_bin[0] |= 0x80 |
||||||
|
return s + ext + v_bin |
||||||
|
|
||||||
|
def mpi2bn(s): |
||||||
|
if len(s) < 4: |
||||||
|
return None |
||||||
|
s_size = bytes(s[:4]) |
||||||
|
v_len = struct.unpack(b">I", s_size)[0] |
||||||
|
if len(s) != (v_len + 4): |
||||||
|
return None |
||||||
|
if v_len == 0: |
||||||
|
return 0 |
||||||
|
|
||||||
|
v_str = bytearray(s[4:]) |
||||||
|
neg = False |
||||||
|
i = v_str[0] |
||||||
|
if i & 0x80: |
||||||
|
neg = True |
||||||
|
i &= ~0x80 |
||||||
|
v_str[0] = i |
||||||
|
|
||||||
|
v = bin2bn(v_str) |
||||||
|
|
||||||
|
if neg: |
||||||
|
return -v |
||||||
|
return v |
||||||
|
|
||||||
|
# navcoin-specific little endian format, with implicit size |
||||||
|
def mpi2vch(s): |
||||||
|
r = s[4:] # strip size |
||||||
|
r = r[::-1] # reverse string, converting BE->LE |
||||||
|
return r |
||||||
|
|
||||||
|
def bn2vch(v): |
||||||
|
return bytes(mpi2vch(bn2mpi(v))) |
||||||
|
|
||||||
|
def vch2mpi(s): |
||||||
|
r = struct.pack(b">I", len(s)) # size |
||||||
|
r += s[::-1] # reverse string, converting LE->BE |
||||||
|
return r |
||||||
|
|
||||||
|
def vch2bn(s): |
||||||
|
return mpi2bn(vch2mpi(s)) |
||||||
|
|
||||||
@ -0,0 +1,106 @@ |
|||||||
|
#!/usr/bin/env python3 |
||||||
|
# Copyright (c) 2015-2016 The Bitcoin Core developers |
||||||
|
# Distributed under the MIT software license, see the accompanying |
||||||
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||||
|
|
||||||
|
""" |
||||||
|
This module contains utilities for doing coverage analysis on the RPC |
||||||
|
interface. |
||||||
|
|
||||||
|
It provides a way to track which RPC commands are exercised during |
||||||
|
testing. |
||||||
|
|
||||||
|
""" |
||||||
|
import os |
||||||
|
|
||||||
|
|
||||||
|
REFERENCE_FILENAME = 'rpc_interface.txt' |
||||||
|
|
||||||
|
|
||||||
|
class AuthServiceProxyWrapper(object): |
||||||
|
""" |
||||||
|
An object that wraps AuthServiceProxy to record specific RPC calls. |
||||||
|
|
||||||
|
""" |
||||||
|
def __init__(self, auth_service_proxy_instance, coverage_logfile=None): |
||||||
|
""" |
||||||
|
Kwargs: |
||||||
|
auth_service_proxy_instance (AuthServiceProxy): the instance |
||||||
|
being wrapped. |
||||||
|
coverage_logfile (str): if specified, write each service_name |
||||||
|
out to a file when called. |
||||||
|
|
||||||
|
""" |
||||||
|
self.auth_service_proxy_instance = auth_service_proxy_instance |
||||||
|
self.coverage_logfile = coverage_logfile |
||||||
|
|
||||||
|
def __getattr__(self, *args, **kwargs): |
||||||
|
return_val = self.auth_service_proxy_instance.__getattr__( |
||||||
|
*args, **kwargs) |
||||||
|
|
||||||
|
return AuthServiceProxyWrapper(return_val, self.coverage_logfile) |
||||||
|
|
||||||
|
def __call__(self, *args, **kwargs): |
||||||
|
""" |
||||||
|
Delegates to AuthServiceProxy, then writes the particular RPC method |
||||||
|
called to a file. |
||||||
|
|
||||||
|
""" |
||||||
|
return_val = self.auth_service_proxy_instance.__call__(*args, **kwargs) |
||||||
|
rpc_method = self.auth_service_proxy_instance._service_name |
||||||
|
|
||||||
|
if self.coverage_logfile: |
||||||
|
with open(self.coverage_logfile, 'a+') as f: |
||||||
|
f.write("%s\n" % rpc_method) |
||||||
|
|
||||||
|
return return_val |
||||||
|
|
||||||
|
@property |
||||||
|
def url(self): |
||||||
|
return self.auth_service_proxy_instance.url |
||||||
|
|
||||||
|
|
||||||
|
def get_filename(dirname, n_node): |
||||||
|
""" |
||||||
|
Get a filename unique to the test process ID and node. |
||||||
|
|
||||||
|
This file will contain a list of RPC commands covered. |
||||||
|
""" |
||||||
|
pid = str(os.getpid()) |
||||||
|
return os.path.join( |
||||||
|
dirname, "coverage.pid%s.node%s.txt" % (pid, str(n_node))) |
||||||
|
|
||||||
|
|
||||||
|
def write_all_rpc_commands(dirname, node): |
||||||
|
""" |
||||||
|
Write out a list of all RPC functions available in `navcoin-cli` for |
||||||
|
coverage comparison. This will only happen once per coverage |
||||||
|
directory. |
||||||
|
|
||||||
|
Args: |
||||||
|
dirname (str): temporary test dir |
||||||
|
node (AuthServiceProxy): client |
||||||
|
|
||||||
|
Returns: |
||||||
|
bool. if the RPC interface file was written. |
||||||
|
|
||||||
|
""" |
||||||
|
filename = os.path.join(dirname, REFERENCE_FILENAME) |
||||||
|
|
||||||
|
if os.path.isfile(filename): |
||||||
|
return False |
||||||
|
|
||||||
|
help_output = node.help().split('\n') |
||||||
|
commands = set() |
||||||
|
|
||||||
|
for line in help_output: |
||||||
|
line = line.strip() |
||||||
|
|
||||||
|
# Ignore blanks and headers |
||||||
|
if line and not line.startswith('='): |
||||||
|
commands.add("%s\n" % line.split()[0]) |
||||||
|
|
||||||
|
with open(filename, 'w') as f: |
||||||
|
f.writelines(list(commands)) |
||||||
|
|
||||||
|
return True |
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,947 @@ |
|||||||
|
#!/usr/bin/env python3 |
||||||
|
# Copyright (c) 2015-2016 The Bitcoin Core developers |
||||||
|
# Distributed under the MIT software license, see the accompanying |
||||||
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||||
|
|
||||||
|
# |
||||||
|
# script.py |
||||||
|
# |
||||||
|
# This file is modified from python-navcoinlib. |
||||||
|
# |
||||||
|
|
||||||
|
"""Scripts |
||||||
|
|
||||||
|
Functionality to build scripts, as well as SignatureHash(). |
||||||
|
""" |
||||||
|
|
||||||
|
|
||||||
|
from .mininode import CTransaction, CTxOut, sha256, hash256, uint256_from_str, ser_uint256, ser_string |
||||||
|
from binascii import hexlify |
||||||
|
import hashlib |
||||||
|
|
||||||
|
import sys |
||||||
|
bchr = chr |
||||||
|
bord = ord |
||||||
|
if sys.version > '3': |
||||||
|
long = int |
||||||
|
bchr = lambda x: bytes([x]) |
||||||
|
bord = lambda x: x |
||||||
|
|
||||||
|
import struct |
||||||
|
|
||||||
|
from .bignum import bn2vch |
||||||
|
|
||||||
|
MAX_SCRIPT_SIZE = 10000 |
||||||
|
MAX_SCRIPT_ELEMENT_SIZE = 520 |
||||||
|
MAX_SCRIPT_OPCODES = 201 |
||||||
|
|
||||||
|
OPCODE_NAMES = {} |
||||||
|
|
||||||
|
def hash160(s): |
||||||
|
return hashlib.new('ripemd160', sha256(s)).digest() |
||||||
|
|
||||||
|
|
||||||
|
_opcode_instances = [] |
||||||
|
class CScriptOp(int): |
||||||
|
"""A single script opcode""" |
||||||
|
__slots__ = [] |
||||||
|
|
||||||
|
@staticmethod |
||||||
|
def encode_op_pushdata(d): |
||||||
|
"""Encode a PUSHDATA op, returning bytes""" |
||||||
|
if len(d) < 0x4c: |
||||||
|
return b'' + bchr(len(d)) + d # OP_PUSHDATA |
||||||
|
elif len(d) <= 0xff: |
||||||
|
return b'\x4c' + bchr(len(d)) + d # OP_PUSHDATA1 |
||||||
|
elif len(d) <= 0xffff: |
||||||
|
return b'\x4d' + struct.pack(b'<H', len(d)) + d # OP_PUSHDATA2 |
||||||
|
elif len(d) <= 0xffffffff: |
||||||
|
return b'\x4e' + struct.pack(b'<I', len(d)) + d # OP_PUSHDATA4 |
||||||
|
else: |
||||||
|
raise ValueError("Data too long to encode in a PUSHDATA op") |
||||||
|
|
||||||
|
@staticmethod |
||||||
|
def encode_op_n(n): |
||||||
|
"""Encode a small integer op, returning an opcode""" |
||||||
|
if not (0 <= n <= 16): |
||||||
|
raise ValueError('Integer must be in range 0 <= n <= 16, got %d' % n) |
||||||
|
|
||||||
|
if n == 0: |
||||||
|
return OP_0 |
||||||
|
else: |
||||||
|
return CScriptOp(OP_1 + n-1) |
||||||
|
|
||||||
|
def decode_op_n(self): |
||||||
|
"""Decode a small integer opcode, returning an integer""" |
||||||
|
if self == OP_0: |
||||||
|
return 0 |
||||||
|
|
||||||
|
if not (self == OP_0 or OP_1 <= self <= OP_16): |
||||||
|
raise ValueError('op %r is not an OP_N' % self) |
||||||
|
|
||||||
|
return int(self - OP_1+1) |
||||||
|
|
||||||
|
def is_small_int(self): |
||||||
|
"""Return true if the op pushes a small integer to the stack""" |
||||||
|
if 0x51 <= self <= 0x60 or self == 0: |
||||||
|
return True |
||||||
|
else: |
||||||
|
return False |
||||||
|
|
||||||
|
def __str__(self): |
||||||
|
return repr(self) |
||||||
|
|
||||||
|
def __repr__(self): |
||||||
|
if self in OPCODE_NAMES: |
||||||
|
return OPCODE_NAMES[self] |
||||||
|
else: |
||||||
|
return 'CScriptOp(0x%x)' % self |
||||||
|
|
||||||
|
def __new__(cls, n): |
||||||
|
try: |
||||||
|
return _opcode_instances[n] |
||||||
|
except IndexError: |
||||||
|
assert len(_opcode_instances) == n |
||||||
|
_opcode_instances.append(super(CScriptOp, cls).__new__(cls, n)) |
||||||
|
return _opcode_instances[n] |
||||||
|
|
||||||
|
# Populate opcode instance table |
||||||
|
for n in range(0xff+1): |
||||||
|
CScriptOp(n) |
||||||
|
|
||||||
|
|
||||||
|
# push value |
||||||
|
OP_0 = CScriptOp(0x00) |
||||||
|
OP_FALSE = OP_0 |
||||||
|
OP_PUSHDATA1 = CScriptOp(0x4c) |
||||||
|
OP_PUSHDATA2 = CScriptOp(0x4d) |
||||||
|
OP_PUSHDATA4 = CScriptOp(0x4e) |
||||||
|
OP_1NEGATE = CScriptOp(0x4f) |
||||||
|
OP_RESERVED = CScriptOp(0x50) |
||||||
|
OP_1 = CScriptOp(0x51) |
||||||
|
OP_TRUE=OP_1 |
||||||
|
OP_2 = CScriptOp(0x52) |
||||||
|
OP_3 = CScriptOp(0x53) |
||||||
|
OP_4 = CScriptOp(0x54) |
||||||
|
OP_5 = CScriptOp(0x55) |
||||||
|
OP_6 = CScriptOp(0x56) |
||||||
|
OP_7 = CScriptOp(0x57) |
||||||
|
OP_8 = CScriptOp(0x58) |
||||||
|
OP_9 = CScriptOp(0x59) |
||||||
|
OP_10 = CScriptOp(0x5a) |
||||||
|
OP_11 = CScriptOp(0x5b) |
||||||
|
OP_12 = CScriptOp(0x5c) |
||||||
|
OP_13 = CScriptOp(0x5d) |
||||||
|
OP_14 = CScriptOp(0x5e) |
||||||
|
OP_15 = CScriptOp(0x5f) |
||||||
|
OP_16 = CScriptOp(0x60) |
||||||
|
|
||||||
|
# control |
||||||
|
OP_NOP = CScriptOp(0x61) |
||||||
|
OP_VER = CScriptOp(0x62) |
||||||
|
OP_IF = CScriptOp(0x63) |
||||||
|
OP_NOTIF = CScriptOp(0x64) |
||||||
|
OP_VERIF = CScriptOp(0x65) |
||||||
|
OP_VERNOTIF = CScriptOp(0x66) |
||||||
|
OP_ELSE = CScriptOp(0x67) |
||||||
|
OP_ENDIF = CScriptOp(0x68) |
||||||
|
OP_VERIFY = CScriptOp(0x69) |
||||||
|
OP_RETURN = CScriptOp(0x6a) |
||||||
|
|
||||||
|
# stack ops |
||||||
|
OP_TOALTSTACK = CScriptOp(0x6b) |
||||||
|
OP_FROMALTSTACK = CScriptOp(0x6c) |
||||||
|
OP_2DROP = CScriptOp(0x6d) |
||||||
|
OP_2DUP = CScriptOp(0x6e) |
||||||
|
OP_3DUP = CScriptOp(0x6f) |
||||||
|
OP_2OVER = CScriptOp(0x70) |
||||||
|
OP_2ROT = CScriptOp(0x71) |
||||||
|
OP_2SWAP = CScriptOp(0x72) |
||||||
|
OP_IFDUP = CScriptOp(0x73) |
||||||
|
OP_DEPTH = CScriptOp(0x74) |
||||||
|
OP_DROP = CScriptOp(0x75) |
||||||
|
OP_DUP = CScriptOp(0x76) |
||||||
|
OP_NIP = CScriptOp(0x77) |
||||||
|
OP_OVER = CScriptOp(0x78) |
||||||
|
OP_PICK = CScriptOp(0x79) |
||||||
|
OP_ROLL = CScriptOp(0x7a) |
||||||
|
OP_ROT = CScriptOp(0x7b) |
||||||
|
OP_SWAP = CScriptOp(0x7c) |
||||||
|
OP_TUCK = CScriptOp(0x7d) |
||||||
|
|
||||||
|
# splice ops |
||||||
|
OP_CAT = CScriptOp(0x7e) |
||||||
|
OP_SUBSTR = CScriptOp(0x7f) |
||||||
|
OP_LEFT = CScriptOp(0x80) |
||||||
|
OP_RIGHT = CScriptOp(0x81) |
||||||
|
OP_SIZE = CScriptOp(0x82) |
||||||
|
|
||||||
|
# bit logic |
||||||
|
OP_INVERT = CScriptOp(0x83) |
||||||
|
OP_AND = CScriptOp(0x84) |
||||||
|
OP_OR = CScriptOp(0x85) |
||||||
|
OP_XOR = CScriptOp(0x86) |
||||||
|
OP_EQUAL = CScriptOp(0x87) |
||||||
|
OP_EQUALVERIFY = CScriptOp(0x88) |
||||||
|
OP_RESERVED1 = CScriptOp(0x89) |
||||||
|
OP_RESERVED2 = CScriptOp(0x8a) |
||||||
|
|
||||||
|
# numeric |
||||||
|
OP_1ADD = CScriptOp(0x8b) |
||||||
|
OP_1SUB = CScriptOp(0x8c) |
||||||
|
OP_2MUL = CScriptOp(0x8d) |
||||||
|
OP_2DIV = CScriptOp(0x8e) |
||||||
|
OP_NEGATE = CScriptOp(0x8f) |
||||||
|
OP_ABS = CScriptOp(0x90) |
||||||
|
OP_NOT = CScriptOp(0x91) |
||||||
|
OP_0NOTEQUAL = CScriptOp(0x92) |
||||||
|
|
||||||
|
OP_ADD = CScriptOp(0x93) |
||||||
|
OP_SUB = CScriptOp(0x94) |
||||||
|
OP_MUL = CScriptOp(0x95) |
||||||
|
OP_DIV = CScriptOp(0x96) |
||||||
|
OP_MOD = CScriptOp(0x97) |
||||||
|
OP_LSHIFT = CScriptOp(0x98) |
||||||
|
OP_RSHIFT = CScriptOp(0x99) |
||||||
|
|
||||||
|
OP_BOOLAND = CScriptOp(0x9a) |
||||||
|
OP_BOOLOR = CScriptOp(0x9b) |
||||||
|
OP_NUMEQUAL = CScriptOp(0x9c) |
||||||
|
OP_NUMEQUALVERIFY = CScriptOp(0x9d) |
||||||
|
OP_NUMNOTEQUAL = CScriptOp(0x9e) |
||||||
|
OP_LESSTHAN = CScriptOp(0x9f) |
||||||
|
OP_GREATERTHAN = CScriptOp(0xa0) |
||||||
|
OP_LESSTHANOREQUAL = CScriptOp(0xa1) |
||||||
|
OP_GREATERTHANOREQUAL = CScriptOp(0xa2) |
||||||
|
OP_MIN = CScriptOp(0xa3) |
||||||
|
OP_MAX = CScriptOp(0xa4) |
||||||
|
|
||||||
|
OP_WITHIN = CScriptOp(0xa5) |
||||||
|
|
||||||
|
# crypto |
||||||
|
OP_RIPEMD160 = CScriptOp(0xa6) |
||||||
|
OP_SHA1 = CScriptOp(0xa7) |
||||||
|
OP_SHA256 = CScriptOp(0xa8) |
||||||
|
OP_HASH160 = CScriptOp(0xa9) |
||||||
|
OP_HASH256 = CScriptOp(0xaa) |
||||||
|
OP_CODESEPARATOR = CScriptOp(0xab) |
||||||
|
OP_CHECKSIG = CScriptOp(0xac) |
||||||
|
OP_CHECKSIGVERIFY = CScriptOp(0xad) |
||||||
|
OP_CHECKMULTISIG = CScriptOp(0xae) |
||||||
|
OP_CHECKMULTISIGVERIFY = CScriptOp(0xaf) |
||||||
|
|
||||||
|
# expansion |
||||||
|
OP_NOP1 = CScriptOp(0xb0) |
||||||
|
OP_CHECKLOCKTIMEVERIFY = CScriptOp(0xb1) |
||||||
|
OP_CHECKSEQUENCEVERIFY = CScriptOp(0xb2) |
||||||
|
OP_NOP4 = CScriptOp(0xb3) |
||||||
|
OP_NOP5 = CScriptOp(0xb4) |
||||||
|
OP_NOP6 = CScriptOp(0xb5) |
||||||
|
OP_NOP7 = CScriptOp(0xb6) |
||||||
|
OP_NOP8 = CScriptOp(0xb7) |
||||||
|
OP_NOP9 = CScriptOp(0xb8) |
||||||
|
OP_NOP10 = CScriptOp(0xb9) |
||||||
|
|
||||||
|
# template matching params |
||||||
|
OP_SMALLINTEGER = CScriptOp(0xfa) |
||||||
|
OP_PUBKEYS = CScriptOp(0xfb) |
||||||
|
OP_PUBKEYHASH = CScriptOp(0xfd) |
||||||
|
OP_PUBKEY = CScriptOp(0xfe) |
||||||
|
|
||||||
|
OP_INVALIDOPCODE = CScriptOp(0xff) |
||||||
|
|
||||||
|
VALID_OPCODES = { |
||||||
|
OP_1NEGATE, |
||||||
|
OP_RESERVED, |
||||||
|
OP_1, |
||||||
|
OP_2, |
||||||
|
OP_3, |
||||||
|
OP_4, |
||||||
|
OP_5, |
||||||
|
OP_6, |
||||||
|
OP_7, |
||||||
|
OP_8, |
||||||
|
OP_9, |
||||||
|
OP_10, |
||||||
|
OP_11, |
||||||
|
OP_12, |
||||||
|
OP_13, |
||||||
|
OP_14, |
||||||
|
OP_15, |
||||||
|
OP_16, |
||||||
|
|
||||||
|
OP_NOP, |
||||||
|
OP_VER, |
||||||
|
OP_IF, |
||||||
|
OP_NOTIF, |
||||||
|
OP_VERIF, |
||||||
|
OP_VERNOTIF, |
||||||
|
OP_ELSE, |
||||||
|
OP_ENDIF, |
||||||
|
OP_VERIFY, |
||||||
|
OP_RETURN, |
||||||
|
|
||||||
|
OP_TOALTSTACK, |
||||||
|
OP_FROMALTSTACK, |
||||||
|
OP_2DROP, |
||||||
|
OP_2DUP, |
||||||
|
OP_3DUP, |
||||||
|
OP_2OVER, |
||||||
|
OP_2ROT, |
||||||
|
OP_2SWAP, |
||||||
|
OP_IFDUP, |
||||||
|
OP_DEPTH, |
||||||
|
OP_DROP, |
||||||
|
OP_DUP, |
||||||
|
OP_NIP, |
||||||
|
OP_OVER, |
||||||
|
OP_PICK, |
||||||
|
OP_ROLL, |
||||||
|
OP_ROT, |
||||||
|
OP_SWAP, |
||||||
|
OP_TUCK, |
||||||
|
|
||||||
|
OP_CAT, |
||||||
|
OP_SUBSTR, |
||||||
|
OP_LEFT, |
||||||
|
OP_RIGHT, |
||||||
|
OP_SIZE, |
||||||
|
|
||||||
|
OP_INVERT, |
||||||
|
OP_AND, |
||||||
|
OP_OR, |
||||||
|
OP_XOR, |
||||||
|
OP_EQUAL, |
||||||
|
OP_EQUALVERIFY, |
||||||
|
OP_RESERVED1, |
||||||
|
OP_RESERVED2, |
||||||
|
|
||||||
|
OP_1ADD, |
||||||
|
OP_1SUB, |
||||||
|
OP_2MUL, |
||||||
|
OP_2DIV, |
||||||
|
OP_NEGATE, |
||||||
|
OP_ABS, |
||||||
|
OP_NOT, |
||||||
|
OP_0NOTEQUAL, |
||||||
|
|
||||||
|
OP_ADD, |
||||||
|
OP_SUB, |
||||||
|
OP_MUL, |
||||||
|
OP_DIV, |
||||||
|
OP_MOD, |
||||||
|
OP_LSHIFT, |
||||||
|
OP_RSHIFT, |
||||||
|
|
||||||
|
OP_BOOLAND, |
||||||
|
OP_BOOLOR, |
||||||
|
OP_NUMEQUAL, |
||||||
|
OP_NUMEQUALVERIFY, |
||||||
|
OP_NUMNOTEQUAL, |
||||||
|
OP_LESSTHAN, |
||||||
|
OP_GREATERTHAN, |
||||||
|
OP_LESSTHANOREQUAL, |
||||||
|
OP_GREATERTHANOREQUAL, |
||||||
|
OP_MIN, |
||||||
|
OP_MAX, |
||||||
|
|
||||||
|
OP_WITHIN, |
||||||
|
|
||||||
|
OP_RIPEMD160, |
||||||
|
OP_SHA1, |
||||||
|
OP_SHA256, |
||||||
|
OP_HASH160, |
||||||
|
OP_HASH256, |
||||||
|
OP_CODESEPARATOR, |
||||||
|
OP_CHECKSIG, |
||||||
|
OP_CHECKSIGVERIFY, |
||||||
|
OP_CHECKMULTISIG, |
||||||
|
OP_CHECKMULTISIGVERIFY, |
||||||
|
|
||||||
|
OP_NOP1, |
||||||
|
OP_CHECKLOCKTIMEVERIFY, |
||||||
|
OP_CHECKSEQUENCEVERIFY, |
||||||
|
OP_NOP4, |
||||||
|
OP_NOP5, |
||||||
|
OP_NOP6, |
||||||
|
OP_NOP7, |
||||||
|
OP_NOP8, |
||||||
|
OP_NOP9, |
||||||
|
OP_NOP10, |
||||||
|
|
||||||
|
OP_SMALLINTEGER, |
||||||
|
OP_PUBKEYS, |
||||||
|
OP_PUBKEYHASH, |
||||||
|
OP_PUBKEY, |
||||||
|
} |
||||||
|
|
||||||
|
OPCODE_NAMES.update({ |
||||||
|
OP_0 : 'OP_0', |
||||||
|
OP_PUSHDATA1 : 'OP_PUSHDATA1', |
||||||
|
OP_PUSHDATA2 : 'OP_PUSHDATA2', |
||||||
|
OP_PUSHDATA4 : 'OP_PUSHDATA4', |
||||||
|
OP_1NEGATE : 'OP_1NEGATE', |
||||||
|
OP_RESERVED : 'OP_RESERVED', |
||||||
|
OP_1 : 'OP_1', |
||||||
|
OP_2 : 'OP_2', |
||||||
|
OP_3 : 'OP_3', |
||||||
|
OP_4 : 'OP_4', |
||||||
|
OP_5 : 'OP_5', |
||||||
|
OP_6 : 'OP_6', |
||||||
|
OP_7 : 'OP_7', |
||||||
|
OP_8 : 'OP_8', |
||||||
|
OP_9 : 'OP_9', |
||||||
|
OP_10 : 'OP_10', |
||||||
|
OP_11 : 'OP_11', |
||||||
|
OP_12 : 'OP_12', |
||||||
|
OP_13 : 'OP_13', |
||||||
|
OP_14 : 'OP_14', |
||||||
|
OP_15 : 'OP_15', |
||||||
|
OP_16 : 'OP_16', |
||||||
|
OP_NOP : 'OP_NOP', |
||||||
|
OP_VER : 'OP_VER', |
||||||
|
OP_IF : 'OP_IF', |
||||||
|
OP_NOTIF : 'OP_NOTIF', |
||||||
|
OP_VERIF : 'OP_VERIF', |
||||||
|
OP_VERNOTIF : 'OP_VERNOTIF', |
||||||
|
OP_ELSE : 'OP_ELSE', |
||||||
|
OP_ENDIF : 'OP_ENDIF', |
||||||
|
OP_VERIFY : 'OP_VERIFY', |
||||||
|
OP_RETURN : 'OP_RETURN', |
||||||
|
OP_TOALTSTACK : 'OP_TOALTSTACK', |
||||||
|
OP_FROMALTSTACK : 'OP_FROMALTSTACK', |
||||||
|
OP_2DROP : 'OP_2DROP', |
||||||
|
OP_2DUP : 'OP_2DUP', |
||||||
|
OP_3DUP : 'OP_3DUP', |
||||||
|
OP_2OVER : 'OP_2OVER', |
||||||
|
OP_2ROT : 'OP_2ROT', |
||||||
|
OP_2SWAP : 'OP_2SWAP', |
||||||
|
OP_IFDUP : 'OP_IFDUP', |
||||||
|
OP_DEPTH : 'OP_DEPTH', |
||||||
|
OP_DROP : 'OP_DROP', |
||||||
|
OP_DUP : 'OP_DUP', |
||||||
|
OP_NIP : 'OP_NIP', |
||||||
|
OP_OVER : 'OP_OVER', |
||||||
|
OP_PICK : 'OP_PICK', |
||||||
|
OP_ROLL : 'OP_ROLL', |
||||||
|
OP_ROT : 'OP_ROT', |
||||||
|
OP_SWAP : 'OP_SWAP', |
||||||
|
OP_TUCK : 'OP_TUCK', |
||||||
|
OP_CAT : 'OP_CAT', |
||||||
|
OP_SUBSTR : 'OP_SUBSTR', |
||||||
|
OP_LEFT : 'OP_LEFT', |
||||||
|
OP_RIGHT : 'OP_RIGHT', |
||||||
|
OP_SIZE : 'OP_SIZE', |
||||||
|
OP_INVERT : 'OP_INVERT', |
||||||
|
OP_AND : 'OP_AND', |
||||||
|
OP_OR : 'OP_OR', |
||||||
|
OP_XOR : 'OP_XOR', |
||||||
|
OP_EQUAL : 'OP_EQUAL', |
||||||
|
OP_EQUALVERIFY : 'OP_EQUALVERIFY', |
||||||
|
OP_RESERVED1 : 'OP_RESERVED1', |
||||||
|
OP_RESERVED2 : 'OP_RESERVED2', |
||||||
|
OP_1ADD : 'OP_1ADD', |
||||||
|
OP_1SUB : 'OP_1SUB', |
||||||
|
OP_2MUL : 'OP_2MUL', |
||||||
|
OP_2DIV : 'OP_2DIV', |
||||||
|
OP_NEGATE : 'OP_NEGATE', |
||||||
|
OP_ABS : 'OP_ABS', |
||||||
|
OP_NOT : 'OP_NOT', |
||||||
|
OP_0NOTEQUAL : 'OP_0NOTEQUAL', |
||||||
|
OP_ADD : 'OP_ADD', |
||||||
|
OP_SUB : 'OP_SUB', |
||||||
|
OP_MUL : 'OP_MUL', |
||||||
|
OP_DIV : 'OP_DIV', |
||||||
|
OP_MOD : 'OP_MOD', |
||||||
|
OP_LSHIFT : 'OP_LSHIFT', |
||||||
|
OP_RSHIFT : 'OP_RSHIFT', |
||||||
|
OP_BOOLAND : 'OP_BOOLAND', |
||||||
|
OP_BOOLOR : 'OP_BOOLOR', |
||||||
|
OP_NUMEQUAL : 'OP_NUMEQUAL', |
||||||
|
OP_NUMEQUALVERIFY : 'OP_NUMEQUALVERIFY', |
||||||
|
OP_NUMNOTEQUAL : 'OP_NUMNOTEQUAL', |
||||||
|
OP_LESSTHAN : 'OP_LESSTHAN', |
||||||
|
OP_GREATERTHAN : 'OP_GREATERTHAN', |
||||||
|
OP_LESSTHANOREQUAL : 'OP_LESSTHANOREQUAL', |
||||||
|
OP_GREATERTHANOREQUAL : 'OP_GREATERTHANOREQUAL', |
||||||
|
OP_MIN : 'OP_MIN', |
||||||
|
OP_MAX : 'OP_MAX', |
||||||
|
OP_WITHIN : 'OP_WITHIN', |
||||||
|
OP_RIPEMD160 : 'OP_RIPEMD160', |
||||||
|
OP_SHA1 : 'OP_SHA1', |
||||||
|
OP_SHA256 : 'OP_SHA256', |
||||||
|
OP_HASH160 : 'OP_HASH160', |
||||||
|
OP_HASH256 : 'OP_HASH256', |
||||||
|
OP_CODESEPARATOR : 'OP_CODESEPARATOR', |
||||||
|
OP_CHECKSIG : 'OP_CHECKSIG', |
||||||
|
OP_CHECKSIGVERIFY : 'OP_CHECKSIGVERIFY', |
||||||
|
OP_CHECKMULTISIG : 'OP_CHECKMULTISIG', |
||||||
|
OP_CHECKMULTISIGVERIFY : 'OP_CHECKMULTISIGVERIFY', |
||||||
|
OP_NOP1 : 'OP_NOP1', |
||||||
|
OP_CHECKLOCKTIMEVERIFY : 'OP_CHECKLOCKTIMEVERIFY', |
||||||
|
OP_CHECKSEQUENCEVERIFY : 'OP_CHECKSEQUENCEVERIFY', |
||||||
|
OP_NOP4 : 'OP_NOP4', |
||||||
|
OP_NOP5 : 'OP_NOP5', |
||||||
|
OP_NOP6 : 'OP_NOP6', |
||||||
|
OP_NOP7 : 'OP_NOP7', |
||||||
|
OP_NOP8 : 'OP_NOP8', |
||||||
|
OP_NOP9 : 'OP_NOP9', |
||||||
|
OP_NOP10 : 'OP_NOP10', |
||||||
|
OP_SMALLINTEGER : 'OP_SMALLINTEGER', |
||||||
|
OP_PUBKEYS : 'OP_PUBKEYS', |
||||||
|
OP_PUBKEYHASH : 'OP_PUBKEYHASH', |
||||||
|
OP_PUBKEY : 'OP_PUBKEY', |
||||||
|
OP_INVALIDOPCODE : 'OP_INVALIDOPCODE', |
||||||
|
}) |
||||||
|
|
||||||
|
OPCODES_BY_NAME = { |
||||||
|
'OP_0' : OP_0, |
||||||
|
'OP_PUSHDATA1' : OP_PUSHDATA1, |
||||||
|
'OP_PUSHDATA2' : OP_PUSHDATA2, |
||||||
|
'OP_PUSHDATA4' : OP_PUSHDATA4, |
||||||
|
'OP_1NEGATE' : OP_1NEGATE, |
||||||
|
'OP_RESERVED' : OP_RESERVED, |
||||||
|
'OP_1' : OP_1, |
||||||
|
'OP_2' : OP_2, |
||||||
|
'OP_3' : OP_3, |
||||||
|
'OP_4' : OP_4, |
||||||
|
'OP_5' : OP_5, |
||||||
|
'OP_6' : OP_6, |
||||||
|
'OP_7' : OP_7, |
||||||
|
'OP_8' : OP_8, |
||||||
|
'OP_9' : OP_9, |
||||||
|
'OP_10' : OP_10, |
||||||
|
'OP_11' : OP_11, |
||||||
|
'OP_12' : OP_12, |
||||||
|
'OP_13' : OP_13, |
||||||
|
'OP_14' : OP_14, |
||||||
|
'OP_15' : OP_15, |
||||||
|
'OP_16' : OP_16, |
||||||
|
'OP_NOP' : OP_NOP, |
||||||
|
'OP_VER' : OP_VER, |
||||||
|
'OP_IF' : OP_IF, |
||||||
|
'OP_NOTIF' : OP_NOTIF, |
||||||
|
'OP_VERIF' : OP_VERIF, |
||||||
|
'OP_VERNOTIF' : OP_VERNOTIF, |
||||||
|
'OP_ELSE' : OP_ELSE, |
||||||
|
'OP_ENDIF' : OP_ENDIF, |
||||||
|
'OP_VERIFY' : OP_VERIFY, |
||||||
|
'OP_RETURN' : OP_RETURN, |
||||||
|
'OP_TOALTSTACK' : OP_TOALTSTACK, |
||||||
|
'OP_FROMALTSTACK' : OP_FROMALTSTACK, |
||||||
|
'OP_2DROP' : OP_2DROP, |
||||||
|
'OP_2DUP' : OP_2DUP, |
||||||
|
'OP_3DUP' : OP_3DUP, |
||||||
|
'OP_2OVER' : OP_2OVER, |
||||||
|
'OP_2ROT' : OP_2ROT, |
||||||
|
'OP_2SWAP' : OP_2SWAP, |
||||||
|
'OP_IFDUP' : OP_IFDUP, |
||||||
|
'OP_DEPTH' : OP_DEPTH, |
||||||
|
'OP_DROP' : OP_DROP, |
||||||
|
'OP_DUP' : OP_DUP, |
||||||
|
'OP_NIP' : OP_NIP, |
||||||
|
'OP_OVER' : OP_OVER, |
||||||
|
'OP_PICK' : OP_PICK, |
||||||
|
'OP_ROLL' : OP_ROLL, |
||||||
|
'OP_ROT' : OP_ROT, |
||||||
|
'OP_SWAP' : OP_SWAP, |
||||||
|
'OP_TUCK' : OP_TUCK, |
||||||
|
'OP_CAT' : OP_CAT, |
||||||
|
'OP_SUBSTR' : OP_SUBSTR, |
||||||
|
'OP_LEFT' : OP_LEFT, |
||||||
|
'OP_RIGHT' : OP_RIGHT, |
||||||
|
'OP_SIZE' : OP_SIZE, |
||||||
|
'OP_INVERT' : OP_INVERT, |
||||||
|
'OP_AND' : OP_AND, |
||||||
|
'OP_OR' : OP_OR, |
||||||
|
'OP_XOR' : OP_XOR, |
||||||
|
'OP_EQUAL' : OP_EQUAL, |
||||||
|
'OP_EQUALVERIFY' : OP_EQUALVERIFY, |
||||||
|
'OP_RESERVED1' : OP_RESERVED1, |
||||||
|
'OP_RESERVED2' : OP_RESERVED2, |
||||||
|
'OP_1ADD' : OP_1ADD, |
||||||
|
'OP_1SUB' : OP_1SUB, |
||||||
|
'OP_2MUL' : OP_2MUL, |
||||||
|
'OP_2DIV' : OP_2DIV, |
||||||
|
'OP_NEGATE' : OP_NEGATE, |
||||||
|
'OP_ABS' : OP_ABS, |
||||||
|
'OP_NOT' : OP_NOT, |
||||||
|
'OP_0NOTEQUAL' : OP_0NOTEQUAL, |
||||||
|
'OP_ADD' : OP_ADD, |
||||||
|
'OP_SUB' : OP_SUB, |
||||||
|
'OP_MUL' : OP_MUL, |
||||||
|
'OP_DIV' : OP_DIV, |
||||||
|
'OP_MOD' : OP_MOD, |
||||||
|
'OP_LSHIFT' : OP_LSHIFT, |
||||||
|
'OP_RSHIFT' : OP_RSHIFT, |
||||||
|
'OP_BOOLAND' : OP_BOOLAND, |
||||||
|
'OP_BOOLOR' : OP_BOOLOR, |
||||||
|
'OP_NUMEQUAL' : OP_NUMEQUAL, |
||||||
|
'OP_NUMEQUALVERIFY' : OP_NUMEQUALVERIFY, |
||||||
|
'OP_NUMNOTEQUAL' : OP_NUMNOTEQUAL, |
||||||
|
'OP_LESSTHAN' : OP_LESSTHAN, |
||||||
|
'OP_GREATERTHAN' : OP_GREATERTHAN, |
||||||
|
'OP_LESSTHANOREQUAL' : OP_LESSTHANOREQUAL, |
||||||
|
'OP_GREATERTHANOREQUAL' : OP_GREATERTHANOREQUAL, |
||||||
|
'OP_MIN' : OP_MIN, |
||||||
|
'OP_MAX' : OP_MAX, |
||||||
|
'OP_WITHIN' : OP_WITHIN, |
||||||
|
'OP_RIPEMD160' : OP_RIPEMD160, |
||||||
|
'OP_SHA1' : OP_SHA1, |
||||||
|
'OP_SHA256' : OP_SHA256, |
||||||
|
'OP_HASH160' : OP_HASH160, |
||||||
|
'OP_HASH256' : OP_HASH256, |
||||||
|
'OP_CODESEPARATOR' : OP_CODESEPARATOR, |
||||||
|
'OP_CHECKSIG' : OP_CHECKSIG, |
||||||
|
'OP_CHECKSIGVERIFY' : OP_CHECKSIGVERIFY, |
||||||
|
'OP_CHECKMULTISIG' : OP_CHECKMULTISIG, |
||||||
|
'OP_CHECKMULTISIGVERIFY' : OP_CHECKMULTISIGVERIFY, |
||||||
|
'OP_NOP1' : OP_NOP1, |
||||||
|
'OP_CHECKLOCKTIMEVERIFY' : OP_CHECKLOCKTIMEVERIFY, |
||||||
|
'OP_CHECKSEQUENCEVERIFY' : OP_CHECKSEQUENCEVERIFY, |
||||||
|
'OP_NOP4' : OP_NOP4, |
||||||
|
'OP_NOP5' : OP_NOP5, |
||||||
|
'OP_NOP6' : OP_NOP6, |
||||||
|
'OP_NOP7' : OP_NOP7, |
||||||
|
'OP_NOP8' : OP_NOP8, |
||||||
|
'OP_NOP9' : OP_NOP9, |
||||||
|
'OP_NOP10' : OP_NOP10, |
||||||
|
'OP_SMALLINTEGER' : OP_SMALLINTEGER, |
||||||
|
'OP_PUBKEYS' : OP_PUBKEYS, |
||||||
|
'OP_PUBKEYHASH' : OP_PUBKEYHASH, |
||||||
|
'OP_PUBKEY' : OP_PUBKEY, |
||||||
|
} |
||||||
|
|
||||||
|
class CScriptInvalidError(Exception): |
||||||
|
"""Base class for CScript exceptions""" |
||||||
|
pass |
||||||
|
|
||||||
|
class CScriptTruncatedPushDataError(CScriptInvalidError): |
||||||
|
"""Invalid pushdata due to truncation""" |
||||||
|
def __init__(self, msg, data): |
||||||
|
self.data = data |
||||||
|
super(CScriptTruncatedPushDataError, self).__init__(msg) |
||||||
|
|
||||||
|
# This is used, eg, for blockchain heights in coinbase scripts (bip34) |
||||||
|
class CScriptNum(object): |
||||||
|
def __init__(self, d=0): |
||||||
|
self.value = d |
||||||
|
|
||||||
|
@staticmethod |
||||||
|
def encode(obj): |
||||||
|
r = bytearray(0) |
||||||
|
if obj.value == 0: |
||||||
|
return bytes(r) |
||||||
|
neg = obj.value < 0 |
||||||
|
absvalue = -obj.value if neg else obj.value |
||||||
|
while (absvalue): |
||||||
|
r.append(absvalue & 0xff) |
||||||
|
absvalue >>= 8 |
||||||
|
if r[-1] & 0x80: |
||||||
|
r.append(0x80 if neg else 0) |
||||||
|
elif neg: |
||||||
|
r[-1] |= 0x80 |
||||||
|
return bytes(bchr(len(r)) + r) |
||||||
|
|
||||||
|
|
||||||
|
class CScript(bytes): |
||||||
|
"""Serialized script |
||||||
|
|
||||||
|
A bytes subclass, so you can use this directly whenever bytes are accepted. |
||||||
|
Note that this means that indexing does *not* work - you'll get an index by |
||||||
|
byte rather than opcode. This format was chosen for efficiency so that the |
||||||
|
general case would not require creating a lot of little CScriptOP objects. |
||||||
|
|
||||||
|
iter(script) however does iterate by opcode. |
||||||
|
""" |
||||||
|
@classmethod |
||||||
|
def __coerce_instance(cls, other): |
||||||
|
# Coerce other into bytes |
||||||
|
if isinstance(other, CScriptOp): |
||||||
|
other = bchr(other) |
||||||
|
elif isinstance(other, CScriptNum): |
||||||
|
if (other.value == 0): |
||||||
|
other = bchr(CScriptOp(OP_0)) |
||||||
|
else: |
||||||
|
other = CScriptNum.encode(other) |
||||||
|
elif isinstance(other, int): |
||||||
|
if 0 <= other <= 16: |
||||||
|
other = bytes(bchr(CScriptOp.encode_op_n(other))) |
||||||
|
elif other == -1: |
||||||
|
other = bytes(bchr(OP_1NEGATE)) |
||||||
|
else: |
||||||
|
other = CScriptOp.encode_op_pushdata(bn2vch(other)) |
||||||
|
elif isinstance(other, (bytes, bytearray)): |
||||||
|
other = CScriptOp.encode_op_pushdata(other) |
||||||
|
return other |
||||||
|
|
||||||
|
def __add__(self, other): |
||||||
|
# Do the coercion outside of the try block so that errors in it are |
||||||
|
# noticed. |
||||||
|
other = self.__coerce_instance(other) |
||||||
|
|
||||||
|
try: |
||||||
|
# bytes.__add__ always returns bytes instances unfortunately |
||||||
|
return CScript(super(CScript, self).__add__(other)) |
||||||
|
except TypeError: |
||||||
|
raise TypeError('Can not add a %r instance to a CScript' % other.__class__) |
||||||
|
|
||||||
|
def join(self, iterable): |
||||||
|
# join makes no sense for a CScript() |
||||||
|
raise NotImplementedError |
||||||
|
|
||||||
|
def __new__(cls, value=b''): |
||||||
|
if isinstance(value, bytes) or isinstance(value, bytearray): |
||||||
|
return super(CScript, cls).__new__(cls, value) |
||||||
|
else: |
||||||
|
def coerce_iterable(iterable): |
||||||
|
for instance in iterable: |
||||||
|
yield cls.__coerce_instance(instance) |
||||||
|
# Annoyingly on both python2 and python3 bytes.join() always |
||||||
|
# returns a bytes instance even when subclassed. |
||||||
|
return super(CScript, cls).__new__(cls, b''.join(coerce_iterable(value))) |
||||||
|
|
||||||
|
def raw_iter(self): |
||||||
|
"""Raw iteration |
||||||
|
|
||||||
|
Yields tuples of (opcode, data, sop_idx) so that the different possible |
||||||
|
PUSHDATA encodings can be accurately distinguished, as well as |
||||||
|
determining the exact opcode byte indexes. (sop_idx) |
||||||
|
""" |
||||||
|
i = 0 |
||||||
|
while i < len(self): |
||||||
|
sop_idx = i |
||||||
|
opcode = bord(self[i]) |
||||||
|
i += 1 |
||||||
|
|
||||||
|
if opcode > OP_PUSHDATA4: |
||||||
|
yield (opcode, None, sop_idx) |
||||||
|
else: |
||||||
|
datasize = None |
||||||
|
pushdata_type = None |
||||||
|
if opcode < OP_PUSHDATA1: |
||||||
|
pushdata_type = 'PUSHDATA(%d)' % opcode |
||||||
|
datasize = opcode |
||||||
|
|
||||||
|
elif opcode == OP_PUSHDATA1: |
||||||
|
pushdata_type = 'PUSHDATA1' |
||||||
|
if i >= len(self): |
||||||
|
raise CScriptInvalidError('PUSHDATA1: missing data length') |
||||||
|
datasize = bord(self[i]) |
||||||
|
i += 1 |
||||||
|
|
||||||
|
elif opcode == OP_PUSHDATA2: |
||||||
|
pushdata_type = 'PUSHDATA2' |
||||||
|
if i + 1 >= len(self): |
||||||
|
raise CScriptInvalidError('PUSHDATA2: missing data length') |
||||||
|
datasize = bord(self[i]) + (bord(self[i+1]) << 8) |
||||||
|
i += 2 |
||||||
|
|
||||||
|
elif opcode == OP_PUSHDATA4: |
||||||
|
pushdata_type = 'PUSHDATA4' |
||||||
|
if i + 3 >= len(self): |
||||||
|
raise CScriptInvalidError('PUSHDATA4: missing data length') |
||||||
|
datasize = bord(self[i]) + (bord(self[i+1]) << 8) + (bord(self[i+2]) << 16) + (bord(self[i+3]) << 24) |
||||||
|
i += 4 |
||||||
|
|
||||||
|
else: |
||||||
|
assert False # shouldn't happen |
||||||
|
|
||||||
|
|
||||||
|
data = bytes(self[i:i+datasize]) |
||||||
|
|
||||||
|
# Check for truncation |
||||||
|
if len(data) < datasize: |
||||||
|
raise CScriptTruncatedPushDataError('%s: truncated data' % pushdata_type, data) |
||||||
|
|
||||||
|
i += datasize |
||||||
|
|
||||||
|
yield (opcode, data, sop_idx) |
||||||
|
|
||||||
|
def __iter__(self): |
||||||
|
"""'Cooked' iteration |
||||||
|
|
||||||
|
Returns either a CScriptOP instance, an integer, or bytes, as |
||||||
|
appropriate. |
||||||
|
|
||||||
|
See raw_iter() if you need to distinguish the different possible |
||||||
|
PUSHDATA encodings. |
||||||
|
""" |
||||||
|
for (opcode, data, sop_idx) in self.raw_iter(): |
||||||
|
if data is not None: |
||||||
|
yield data |
||||||
|
else: |
||||||
|
opcode = CScriptOp(opcode) |
||||||
|
|
||||||
|
if opcode.is_small_int(): |
||||||
|
yield opcode.decode_op_n() |
||||||
|
else: |
||||||
|
yield CScriptOp(opcode) |
||||||
|
|
||||||
|
def __repr__(self): |
||||||
|
# For Python3 compatibility add b before strings so testcases don't |
||||||
|
# need to change |
||||||
|
def _repr(o): |
||||||
|
if isinstance(o, bytes): |
||||||
|
return b"x('%s')" % hexlify(o).decode('ascii') |
||||||
|
else: |
||||||
|
return repr(o) |
||||||
|
|
||||||
|
ops = [] |
||||||
|
i = iter(self) |
||||||
|
while True: |
||||||
|
op = None |
||||||
|
try: |
||||||
|
op = _repr(next(i)) |
||||||
|
except CScriptTruncatedPushDataError as err: |
||||||
|
op = '%s...<ERROR: %s>' % (_repr(err.data), err) |
||||||
|
break |
||||||
|
except CScriptInvalidError as err: |
||||||
|
op = '<ERROR: %s>' % err |
||||||
|
break |
||||||
|
except StopIteration: |
||||||
|
break |
||||||
|
finally: |
||||||
|
if op is not None: |
||||||
|
ops.append(op) |
||||||
|
|
||||||
|
return "CScript([%s])" % ', '.join(ops) |
||||||
|
|
||||||
|
def GetSigOpCount(self, fAccurate): |
||||||
|
"""Get the SigOp count. |
||||||
|
|
||||||
|
fAccurate - Accurately count CHECKMULTISIG, see BIP16 for details. |
||||||
|
|
||||||
|
Note that this is consensus-critical. |
||||||
|
""" |
||||||
|
n = 0 |
||||||
|
lastOpcode = OP_INVALIDOPCODE |
||||||
|
for (opcode, data, sop_idx) in self.raw_iter(): |
||||||
|
if opcode in (OP_CHECKSIG, OP_CHECKSIGVERIFY): |
||||||
|
n += 1 |
||||||
|
elif opcode in (OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY): |
||||||
|
if fAccurate and (OP_1 <= lastOpcode <= OP_16): |
||||||
|
n += opcode.decode_op_n() |
||||||
|
else: |
||||||
|
n += 20 |
||||||
|
lastOpcode = opcode |
||||||
|
return n |
||||||
|
|
||||||
|
|
||||||
|
SIGHASH_ALL = 1 |
||||||
|
SIGHASH_NONE = 2 |
||||||
|
SIGHASH_SINGLE = 3 |
||||||
|
SIGHASH_ANYONECANPAY = 0x80 |
||||||
|
|
||||||
|
def FindAndDelete(script, sig): |
||||||
|
"""Consensus critical, see FindAndDelete() in Satoshi codebase""" |
||||||
|
r = b'' |
||||||
|
last_sop_idx = sop_idx = 0 |
||||||
|
skip = True |
||||||
|
for (opcode, data, sop_idx) in script.raw_iter(): |
||||||
|
if not skip: |
||||||
|
r += script[last_sop_idx:sop_idx] |
||||||
|
last_sop_idx = sop_idx |
||||||
|
if script[sop_idx:sop_idx + len(sig)] == sig: |
||||||
|
skip = True |
||||||
|
else: |
||||||
|
skip = False |
||||||
|
if not skip: |
||||||
|
r += script[last_sop_idx:] |
||||||
|
return CScript(r) |
||||||
|
|
||||||
|
|
||||||
|
def SignatureHash(script, txTo, inIdx, hashtype): |
||||||
|
"""Consensus-correct SignatureHash |
||||||
|
|
||||||
|
Returns (hash, err) to precisely match the consensus-critical behavior of |
||||||
|
the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity) |
||||||
|
""" |
||||||
|
HASH_ONE = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' |
||||||
|
|
||||||
|
if inIdx >= len(txTo.vin): |
||||||
|
return (HASH_ONE, "inIdx %d out of range (%d)" % (inIdx, len(txTo.vin))) |
||||||
|
txtmp = CTransaction(txTo) |
||||||
|
|
||||||
|
for txin in txtmp.vin: |
||||||
|
txin.scriptSig = b'' |
||||||
|
txtmp.vin[inIdx].scriptSig = FindAndDelete(script, CScript([OP_CODESEPARATOR])) |
||||||
|
|
||||||
|
if (hashtype & 0x1f) == SIGHASH_NONE: |
||||||
|
txtmp.vout = [] |
||||||
|
|
||||||
|
for i in range(len(txtmp.vin)): |
||||||
|
if i != inIdx: |
||||||
|
txtmp.vin[i].nSequence = 0 |
||||||
|
|
||||||
|
elif (hashtype & 0x1f) == SIGHASH_SINGLE: |
||||||
|
outIdx = inIdx |
||||||
|
if outIdx >= len(txtmp.vout): |
||||||
|
return (HASH_ONE, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout))) |
||||||
|
|
||||||
|
tmp = txtmp.vout[outIdx] |
||||||
|
txtmp.vout = [] |
||||||
|
for i in range(outIdx): |
||||||
|
txtmp.vout.append(CTxOut()) |
||||||
|
txtmp.vout.append(tmp) |
||||||
|
|
||||||
|
for i in range(len(txtmp.vin)): |
||||||
|
if i != inIdx: |
||||||
|
txtmp.vin[i].nSequence = 0 |
||||||
|
|
||||||
|
if hashtype & SIGHASH_ANYONECANPAY: |
||||||
|
tmp = txtmp.vin[inIdx] |
||||||
|
txtmp.vin = [] |
||||||
|
txtmp.vin.append(tmp) |
||||||
|
|
||||||
|
s = txtmp.serialize() |
||||||
|
s += struct.pack(b"<I", hashtype) |
||||||
|
|
||||||
|
hash = hash256(s) |
||||||
|
|
||||||
|
return (hash, None) |
||||||
|
|
||||||
|
# TODO: Allow cached hashPrevouts/hashSequence/hashOutputs to be provided. |
||||||
|
# Performance optimization probably not necessary for python tests, however. |
||||||
|
# Note that this corresponds to sigversion == 1 in EvalScript, which is used |
||||||
|
# for version 0 witnesses. |
||||||
|
def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount): |
||||||
|
|
||||||
|
hashPrevouts = 0 |
||||||
|
hashSequence = 0 |
||||||
|
hashOutputs = 0 |
||||||
|
|
||||||
|
if not (hashtype & SIGHASH_ANYONECANPAY): |
||||||
|
serialize_prevouts = bytes() |
||||||
|
for i in txTo.vin: |
||||||
|
serialize_prevouts += i.prevout.serialize() |
||||||
|
hashPrevouts = uint256_from_str(hash256(serialize_prevouts)) |
||||||
|
|
||||||
|
if (not (hashtype & SIGHASH_ANYONECANPAY) and (hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE): |
||||||
|
serialize_sequence = bytes() |
||||||
|
for i in txTo.vin: |
||||||
|
serialize_sequence += struct.pack("<I", i.nSequence) |
||||||
|
hashSequence = uint256_from_str(hash256(serialize_sequence)) |
||||||
|
|
||||||
|
if ((hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE): |
||||||
|
serialize_outputs = bytes() |
||||||
|
for o in txTo.vout: |
||||||
|
serialize_outputs += o.serialize() |
||||||
|
hashOutputs = uint256_from_str(hash256(serialize_outputs)) |
||||||
|
elif ((hashtype & 0x1f) == SIGHASH_SINGLE and inIdx < len(txTo.vout)): |
||||||
|
serialize_outputs = txTo.vout[inIdx].serialize() |
||||||
|
hashOutputs = uint256_from_str(hash256(serialize_outputs)) |
||||||
|
|
||||||
|
ss = bytes() |
||||||
|
ss += struct.pack("<i", txTo.nVersion) |
||||||
|
ss += ser_uint256(hashPrevouts) |
||||||
|
ss += ser_uint256(hashSequence) |
||||||
|
ss += txTo.vin[inIdx].prevout.serialize() |
||||||
|
ss += ser_string(script) |
||||||
|
ss += struct.pack("<q", amount) |
||||||
|
ss += struct.pack("<I", txTo.vin[inIdx].nSequence) |
||||||
|
ss += ser_uint256(hashOutputs) |
||||||
|
ss += struct.pack("<i", txTo.nLockTime) |
||||||
|
ss += struct.pack("<I", hashtype) |
||||||
|
|
||||||
|
return hash256(ss) |
||||||
@ -0,0 +1,63 @@ |
|||||||
|
#!/usr/bin/env python3 |
||||||
|
# Copyright (c) 2016-2018 The Bitcoin Core developers |
||||||
|
# Distributed under the MIT software license, see the accompanying |
||||||
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||||
|
"""Specialized SipHash-2-4 implementations. |
||||||
|
|
||||||
|
This implements SipHash-2-4 for 256-bit integers. |
||||||
|
""" |
||||||
|
|
||||||
|
def rotl64(n, b): |
||||||
|
return n >> (64 - b) | (n & ((1 << (64 - b)) - 1)) << b |
||||||
|
|
||||||
|
def siphash_round(v0, v1, v2, v3): |
||||||
|
v0 = (v0 + v1) & ((1 << 64) - 1) |
||||||
|
v1 = rotl64(v1, 13) |
||||||
|
v1 ^= v0 |
||||||
|
v0 = rotl64(v0, 32) |
||||||
|
v2 = (v2 + v3) & ((1 << 64) - 1) |
||||||
|
v3 = rotl64(v3, 16) |
||||||
|
v3 ^= v2 |
||||||
|
v0 = (v0 + v3) & ((1 << 64) - 1) |
||||||
|
v3 = rotl64(v3, 21) |
||||||
|
v3 ^= v0 |
||||||
|
v2 = (v2 + v1) & ((1 << 64) - 1) |
||||||
|
v1 = rotl64(v1, 17) |
||||||
|
v1 ^= v2 |
||||||
|
v2 = rotl64(v2, 32) |
||||||
|
return (v0, v1, v2, v3) |
||||||
|
|
||||||
|
def siphash256(k0, k1, h): |
||||||
|
n0 = h & ((1 << 64) - 1) |
||||||
|
n1 = (h >> 64) & ((1 << 64) - 1) |
||||||
|
n2 = (h >> 128) & ((1 << 64) - 1) |
||||||
|
n3 = (h >> 192) & ((1 << 64) - 1) |
||||||
|
v0 = 0x736f6d6570736575 ^ k0 |
||||||
|
v1 = 0x646f72616e646f6d ^ k1 |
||||||
|
v2 = 0x6c7967656e657261 ^ k0 |
||||||
|
v3 = 0x7465646279746573 ^ k1 ^ n0 |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0 ^= n0 |
||||||
|
v3 ^= n1 |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0 ^= n1 |
||||||
|
v3 ^= n2 |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0 ^= n2 |
||||||
|
v3 ^= n3 |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0 ^= n3 |
||||||
|
v3 ^= 0x2000000000000000 |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0 ^= 0x2000000000000000 |
||||||
|
v2 ^= 0xFF |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3) |
||||||
|
return v0 ^ v1 ^ v2 ^ v3 |
||||||
@ -0,0 +1,700 @@ |
|||||||
|
#!/usr/bin/env python3 |
||||||
|
# Copyright (c) 2014-2016 The Bitcoin Core developers |
||||||
|
# Distributed under the MIT software license, see the accompanying |
||||||
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||||
|
|
||||||
|
|
||||||
|
# |
||||||
|
# Helpful routines for regression testing |
||||||
|
# |
||||||
|
|
||||||
|
import os |
||||||
|
import sys |
||||||
|
|
||||||
|
from binascii import hexlify, unhexlify |
||||||
|
from base64 import b64encode |
||||||
|
from decimal import Decimal, ROUND_DOWN |
||||||
|
import json |
||||||
|
import http.client |
||||||
|
import random |
||||||
|
import shutil |
||||||
|
import subprocess |
||||||
|
import time |
||||||
|
import re |
||||||
|
import errno |
||||||
|
|
||||||
|
from . import coverage |
||||||
|
from .authproxy import AuthServiceProxy, JSONRPCException |
||||||
|
|
||||||
|
COVERAGE_DIR = None |
||||||
|
|
||||||
|
# The maximum number of nodes a single test can spawn |
||||||
|
MAX_NODES = 8 |
||||||
|
# Don't assign rpc or p2p ports lower than this |
||||||
|
PORT_MIN = 11000 |
||||||
|
# The number of ports to "reserve" for p2p and rpc, each |
||||||
|
PORT_RANGE = 5000 |
||||||
|
|
||||||
|
NAVCOIND_PROC_WAIT_TIMEOUT = 60 |
||||||
|
|
||||||
|
|
||||||
|
class PortSeed: |
||||||
|
# Must be initialized with a unique integer for each process |
||||||
|
n = None |
||||||
|
|
||||||
|
#Set Mocktime default to OFF. |
||||||
|
#MOCKTIME is only needed for scripts that use the |
||||||
|
#cached version of the blockchain. If the cached |
||||||
|
#version of the blockchain is used without MOCKTIME |
||||||
|
#then the mempools will not sync due to IBD. |
||||||
|
MOCKTIME = 0 |
||||||
|
|
||||||
|
def enable_mocktime(): |
||||||
|
#For backwared compatibility of the python scripts |
||||||
|
#with previous versions of the cache, set MOCKTIME |
||||||
|
#to Jan 1, 2014 + (201 * 10 * 60) |
||||||
|
global MOCKTIME |
||||||
|
MOCKTIME = 1388534400 + (201 * 10 * 60) |
||||||
|
|
||||||
|
def disable_mocktime(): |
||||||
|
global MOCKTIME |
||||||
|
MOCKTIME = 0 |
||||||
|
|
||||||
|
def get_mocktime(): |
||||||
|
return MOCKTIME |
||||||
|
|
||||||
|
def enable_coverage(dirname): |
||||||
|
"""Maintain a log of which RPC calls are made during testing.""" |
||||||
|
global COVERAGE_DIR |
||||||
|
COVERAGE_DIR = dirname |
||||||
|
|
||||||
|
def get_rpc_proxy(url, node_number, timeout=None): |
||||||
|
""" |
||||||
|
Args: |
||||||
|
url (str): URL of the RPC server to call |
||||||
|
node_number (int): the node number (or id) that this calls to |
||||||
|
|
||||||
|
Kwargs: |
||||||
|
timeout (int): HTTP timeout in seconds |
||||||
|
|
||||||
|
Returns: |
||||||
|
AuthServiceProxy. convenience object for making RPC calls. |
||||||
|
|
||||||
|
""" |
||||||
|
proxy_kwargs = {} |
||||||
|
if timeout is not None: |
||||||
|
proxy_kwargs['timeout'] = timeout |
||||||
|
|
||||||
|
proxy = AuthServiceProxy(url, **proxy_kwargs) |
||||||
|
proxy.url = url # store URL on proxy for info |
||||||
|
|
||||||
|
coverage_logfile = coverage.get_filename( |
||||||
|
COVERAGE_DIR, node_number) if COVERAGE_DIR else None |
||||||
|
|
||||||
|
return coverage.AuthServiceProxyWrapper(proxy, coverage_logfile) |
||||||
|
|
||||||
|
|
||||||
|
def p2p_port(n): |
||||||
|
assert(n <= MAX_NODES) |
||||||
|
return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES) |
||||||
|
|
||||||
|
def rpc_port(n): |
||||||
|
return PORT_MIN + PORT_RANGE + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES) |
||||||
|
|
||||||
|
def check_json_precision(): |
||||||
|
"""Make sure json library being used does not lose precision converting NAV values""" |
||||||
|
n = Decimal("20000000.00000003") |
||||||
|
satoshis = int(json.loads(json.dumps(float(n)))*1.0e8) |
||||||
|
if satoshis != 2000000000000003: |
||||||
|
raise RuntimeError("JSON encode/decode loses precision") |
||||||
|
|
||||||
|
def count_bytes(hex_string): |
||||||
|
return len(bytearray.fromhex(hex_string)) |
||||||
|
|
||||||
|
def bytes_to_hex_str(byte_str): |
||||||
|
return hexlify(byte_str).decode('ascii') |
||||||
|
|
||||||
|
def hex_str_to_bytes(hex_str): |
||||||
|
return unhexlify(hex_str.encode('ascii')) |
||||||
|
|
||||||
|
def str_to_b64str(string): |
||||||
|
return b64encode(string.encode('utf-8')).decode('ascii') |
||||||
|
|
||||||
|
def sync_blocks(rpc_connections, wait=1, timeout=60): |
||||||
|
""" |
||||||
|
Wait until everybody has the same tip |
||||||
|
""" |
||||||
|
while timeout > 0: |
||||||
|
tips = [ x.getbestblockhash() for x in rpc_connections ] |
||||||
|
if tips == [ tips[0] ]*len(tips): |
||||||
|
#if all x.getblockhash() in tips are the same return True |
||||||
|
return True |
||||||
|
time.sleep(wait) |
||||||
|
timeout -= wait |
||||||
|
raise AssertionError("Block sync failed") |
||||||
|
|
||||||
|
def sync_mempools(rpc_connections, wait=1, timeout=60): |
||||||
|
""" |
||||||
|
Wait until everybody has the same transactions in their memory |
||||||
|
pools |
||||||
|
""" |
||||||
|
while timeout > 0: |
||||||
|
pool = set(rpc_connections[0].getrawmempool()) |
||||||
|
num_match = 1 |
||||||
|
for i in range(1, len(rpc_connections)): |
||||||
|
if set(rpc_connections[i].getrawmempool()) == pool: |
||||||
|
num_match = num_match+1 |
||||||
|
if num_match == len(rpc_connections): |
||||||
|
return True |
||||||
|
time.sleep(wait) |
||||||
|
timeout -= wait |
||||||
|
raise AssertionError("Mempool sync failed") |
||||||
|
|
||||||
|
navcoind_processes = {} |
||||||
|
|
||||||
|
def initialize_datadir(dirname, n): |
||||||
|
datadir = os.path.join(dirname, "node"+str(n)) |
||||||
|
if not os.path.isdir(datadir): |
||||||
|
os.makedirs(datadir) |
||||||
|
rpc_u, rpc_p = rpc_auth_pair(n) |
||||||
|
with open(os.path.join(datadir, "navcoin.conf"), 'w') as f: |
||||||
|
f.write("devnet=1\n") |
||||||
|
f.write("rpcuser=" + rpc_u + "\n") |
||||||
|
f.write("rpcpassword=" + rpc_p + "\n") |
||||||
|
f.write("port="+str(p2p_port(n))+"\n") |
||||||
|
f.write("rpcport="+str(rpc_port(n))+"\n") |
||||||
|
f.write("listenonion=0\n") |
||||||
|
f.write("dandelion=0\n") |
||||||
|
f.write("ntpminmeasures=-1\n") |
||||||
|
f.write("torserver=0\n") |
||||||
|
f.write("suppressblsctwarning=1\n") |
||||||
|
return datadir |
||||||
|
|
||||||
|
def rpc_auth_pair(n): |
||||||
|
return 'rpcuser💻' + str(n), 'rpcpass🔑' + str(n) |
||||||
|
|
||||||
|
def rpc_url(i, rpchost=None): |
||||||
|
rpc_u, rpc_p = rpc_auth_pair(i) |
||||||
|
return "http://%s:%s@%s:%d" % (rpc_u, rpc_p, rpchost or '127.0.0.1', rpc_port(i)) |
||||||
|
|
||||||
|
def wait_for_navcoind_start(process, url, i): |
||||||
|
''' |
||||||
|
Wait for navcoind to start. This means that RPC is accessible and fully initialized. |
||||||
|
Raise an exception if navcoind exits during initialization. |
||||||
|
''' |
||||||
|
polls_interval = 1.0 / 4 |
||||||
|
runtime = 60 |
||||||
|
while runtime > 0: |
||||||
|
if process.poll() is not None: |
||||||
|
raise Exception('navcoind exited with status %i during initialization' % process.returncode) |
||||||
|
try: |
||||||
|
# print('Checking RPC') |
||||||
|
rpc = get_rpc_proxy(url, i) |
||||||
|
blocks = rpc.getblockcount() |
||||||
|
# print('RPC replied with blocks: %i' % blocks) |
||||||
|
return # break out of loop on success |
||||||
|
except IOError as e: |
||||||
|
if e.errno != errno.ECONNREFUSED: # Port not yet open? |
||||||
|
raise # unknown IO error |
||||||
|
# else: |
||||||
|
# print('Waiting for port') |
||||||
|
except JSONRPCException as e: # Initialization phase |
||||||
|
if e.error['code'] != -28: # RPC in warmup? |
||||||
|
raise # unkown JSON RPC exception |
||||||
|
# else: |
||||||
|
# print('RPC in warmup') |
||||||
|
time.sleep(polls_interval) |
||||||
|
runtime -= polls_interval |
||||||
|
raise Exception('navcoind RPC timeout') |
||||||
|
|
||||||
|
def initialize_chain(test_dir, num_nodes): |
||||||
|
""" |
||||||
|
Create a cache of a 200-block-long chain (with wallet) for MAX_NODES |
||||||
|
Afterward, create num_nodes copies from the cache |
||||||
|
""" |
||||||
|
|
||||||
|
assert num_nodes <= MAX_NODES |
||||||
|
create_cache = False |
||||||
|
for i in range(MAX_NODES): |
||||||
|
if not os.path.isdir(os.path.join('cache', 'node'+str(i))): |
||||||
|
create_cache = True |
||||||
|
break |
||||||
|
|
||||||
|
if create_cache: |
||||||
|
|
||||||
|
#find and delete old cache directories if any exist |
||||||
|
for i in range(MAX_NODES): |
||||||
|
if os.path.isdir(os.path.join("cache","node"+str(i))): |
||||||
|
shutil.rmtree(os.path.join("cache","node"+str(i))) |
||||||
|
|
||||||
|
# Create cache directories, run navcoinds: |
||||||
|
for i in range(MAX_NODES): |
||||||
|
datadir=initialize_datadir("cache", i) |
||||||
|
args = [ os.getenv("NAVCOIND", "navcoind"), "-server", "-keypool=1", "-datadir="+datadir, "-discover=0" ] |
||||||
|
if i > 0: |
||||||
|
args.append("-connect=127.0.0.1:"+str(p2p_port(0))) |
||||||
|
navcoind_processes[i] = subprocess.Popen(args) |
||||||
|
if os.getenv("PYTHON_DEBUG", ""): |
||||||
|
print("initialize_chain: navcoind started, waiting for RPC to come up") |
||||||
|
wait_for_navcoind_start(navcoind_processes[i], rpc_url(i), i) |
||||||
|
if os.getenv("PYTHON_DEBUG", ""): |
||||||
|
print("initialize_chain: RPC succesfully started") |
||||||
|
|
||||||
|
rpcs = [] |
||||||
|
for i in range(MAX_NODES): |
||||||
|
try: |
||||||
|
rpcs.append(get_rpc_proxy(rpc_url(i), i)) |
||||||
|
except: |
||||||
|
sys.stderr.write("Error connecting to "+url+"\n") |
||||||
|
sys.exit(1) |
||||||
|
|
||||||
|
# Create a 200-block-long chain; each of the 4 first nodes |
||||||
|
# gets 25 mature blocks and 25 immature. |
||||||
|
# Note: To preserve compatibility with older versions of |
||||||
|
# initialize_chain, only 4 nodes will generate coins. |
||||||
|
# |
||||||
|
# blocks are created with timestamps 10 minutes apart |
||||||
|
# starting from 2010 minutes in the past |
||||||
|
enable_mocktime() |
||||||
|
block_time = get_mocktime() - (201 * 10 * 60) |
||||||
|
for i in range(2): |
||||||
|
for peer in range(4): |
||||||
|
for j in range(25): |
||||||
|
set_node_times(rpcs, block_time) |
||||||
|
slow_gen(rpcs[peer], 1) |
||||||
|
block_time += 10*60 |
||||||
|
# Must sync before next peer starts generating blocks |
||||||
|
sync_blocks(rpcs) |
||||||
|
|
||||||
|
# Shut them down, and clean up cache directories: |
||||||
|
stop_nodes(rpcs) |
||||||
|
wait_navcoinds() |
||||||
|
disable_mocktime() |
||||||
|
for i in range(MAX_NODES): |
||||||
|
os.remove(log_filename("cache", i, "debug.log")) |
||||||
|
os.remove(log_filename("cache", i, "db.log")) |
||||||
|
os.remove(log_filename("cache", i, "peers.dat")) |
||||||
|
os.remove(log_filename("cache", i, "fee_estimates.dat")) |
||||||
|
|
||||||
|
for i in range(num_nodes): |
||||||
|
from_dir = os.path.join("cache", "node"+str(i)) |
||||||
|
to_dir = os.path.join(test_dir, "node"+str(i)) |
||||||
|
shutil.copytree(from_dir, to_dir) |
||||||
|
initialize_datadir(test_dir, i) # Overwrite port/rpcport in navcoin.conf |
||||||
|
|
||||||
|
def initialize_chain_clean(test_dir, num_nodes): |
||||||
|
""" |
||||||
|
Create an empty blockchain and num_nodes wallets. |
||||||
|
Useful if a test case wants complete control over initialization. |
||||||
|
""" |
||||||
|
for i in range(num_nodes): |
||||||
|
datadir=initialize_datadir(test_dir, i) |
||||||
|
|
||||||
|
|
||||||
|
def _rpchost_to_args(rpchost): |
||||||
|
'''Convert optional IP:port spec to rpcconnect/rpcport args''' |
||||||
|
if rpchost is None: |
||||||
|
return [] |
||||||
|
|
||||||
|
match = re.match('(\[[0-9a-fA-f:]+\]|[^:]+)(?::([0-9]+))?$', rpchost) |
||||||
|
if not match: |
||||||
|
raise ValueError('Invalid RPC host spec ' + rpchost) |
||||||
|
|
||||||
|
rpcconnect = match.group(1) |
||||||
|
rpcport = match.group(2) |
||||||
|
|
||||||
|
if rpcconnect.startswith('['): # remove IPv6 [...] wrapping |
||||||
|
rpcconnect = rpcconnect[1:-1] |
||||||
|
|
||||||
|
rv = ['-rpcconnect=' + rpcconnect] |
||||||
|
if rpcport: |
||||||
|
rv += ['-rpcport=' + rpcport] |
||||||
|
return rv |
||||||
|
|
||||||
|
def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None): |
||||||
|
""" |
||||||
|
Start a navcoind and return RPC connection to it |
||||||
|
""" |
||||||
|
datadir = os.path.join(dirname, "node"+str(i)) |
||||||
|
if binary is None: |
||||||
|
binary = os.getenv("NAVCOIND", "navcoind") |
||||||
|
args = [ binary, "-datadir="+datadir, "-server", "-keypool=1", "-discover=0", "-rest", "-mocktime="+str(get_mocktime()) ] |
||||||
|
if extra_args is not None: args.extend(extra_args) |
||||||
|
navcoind_processes[i] = subprocess.Popen(args) |
||||||
|
if os.getenv("PYTHON_DEBUG", ""): |
||||||
|
print("start_node: navcoind started, waiting for RPC to come up") |
||||||
|
url = rpc_url(i, rpchost) |
||||||
|
wait_for_navcoind_start(navcoind_processes[i], url, i) |
||||||
|
if os.getenv("PYTHON_DEBUG", ""): |
||||||
|
print("start_node: RPC succesfully started") |
||||||
|
proxy = get_rpc_proxy(url, i, timeout=timewait) |
||||||
|
|
||||||
|
if COVERAGE_DIR: |
||||||
|
coverage.write_all_rpc_commands(COVERAGE_DIR, proxy) |
||||||
|
|
||||||
|
return proxy |
||||||
|
|
||||||
|
def start_nodes(num_nodes, dirname, extra_args=None, rpchost=None, binary=None): |
||||||
|
""" |
||||||
|
Start multiple navcoinds, return RPC connections to them |
||||||
|
""" |
||||||
|
if extra_args is None: extra_args = [ None for _ in range(num_nodes) ] |
||||||
|
if binary is None: binary = [ None for _ in range(num_nodes) ] |
||||||
|
rpcs = [] |
||||||
|
try: |
||||||
|
for i in range(num_nodes): |
||||||
|
rpcs.append(start_node(i, dirname, extra_args[i], rpchost, binary=binary[i])) |
||||||
|
except: # If one node failed to start, stop the others |
||||||
|
stop_nodes(rpcs) |
||||||
|
raise |
||||||
|
return rpcs |
||||||
|
|
||||||
|
def log_filename(dirname, n_node, logname): |
||||||
|
return os.path.join(dirname, "node"+str(n_node), "devnet", logname) |
||||||
|
|
||||||
|
def stop_node(node, i): |
||||||
|
try: |
||||||
|
node.stop() |
||||||
|
except http.client.CannotSendRequest as e: |
||||||
|
print("WARN: Unable to stop node: " + repr(e)) |
||||||
|
navcoind_processes[i].wait(timeout=NAVCOIND_PROC_WAIT_TIMEOUT) |
||||||
|
del navcoind_processes[i] |
||||||
|
|
||||||
|
def stop_nodes(nodes): |
||||||
|
for node in nodes: |
||||||
|
try: |
||||||
|
node.stop() |
||||||
|
except http.client.CannotSendRequest as e: |
||||||
|
print("WARN: Unable to stop node: " + repr(e)) |
||||||
|
del nodes[:] # Emptying array closes connections as a side effect |
||||||
|
|
||||||
|
def set_node_times(nodes, t): |
||||||
|
for node in nodes: |
||||||
|
node.setmocktime(t) |
||||||
|
|
||||||
|
def wait_navcoinds(): |
||||||
|
# Wait for all navcoinds to cleanly exit |
||||||
|
for navcoind in navcoind_processes.values(): |
||||||
|
navcoind.wait(timeout=NAVCOIND_PROC_WAIT_TIMEOUT) |
||||||
|
navcoind_processes.clear() |
||||||
|
|
||||||
|
def connect_nodes(from_connection, node_num): |
||||||
|
ip_port = "127.0.0.1:"+str(p2p_port(node_num)) |
||||||
|
from_connection.addnode(ip_port, "onetry") |
||||||
|
# poll until version handshake complete to avoid race conditions |
||||||
|
# with transaction relaying |
||||||
|
while any(peer['version'] == 0 for peer in from_connection.getpeerinfo()): |
||||||
|
time.sleep(0.1) |
||||||
|
|
||||||
|
def connect_nodes_bi(nodes, a, b): |
||||||
|
connect_nodes(nodes[a], b) |
||||||
|
connect_nodes(nodes[b], a) |
||||||
|
|
||||||
|
def find_output(node, txid, amount): |
||||||
|
""" |
||||||
|
Return index to output of txid with value amount |
||||||
|
Raises exception if there is none. |
||||||
|
""" |
||||||
|
txdata = node.getrawtransaction(txid, 1) |
||||||
|
for i in range(len(txdata["vout"])): |
||||||
|
if txdata["vout"][i]["value"] == amount: |
||||||
|
return i |
||||||
|
raise RuntimeError("find_output txid %s : %s not found"%(txid,str(amount))) |
||||||
|
|
||||||
|
|
||||||
|
def gather_inputs(from_node, amount_needed, confirmations_required=1): |
||||||
|
""" |
||||||
|
Return a random set of unspent txouts that are enough to pay amount_needed |
||||||
|
""" |
||||||
|
assert(confirmations_required >=0) |
||||||
|
utxo = from_node.listunspent(confirmations_required) |
||||||
|
random.shuffle(utxo) |
||||||
|
inputs = [] |
||||||
|
total_in = Decimal("0.00000000") |
||||||
|
while total_in < amount_needed and len(utxo) > 0: |
||||||
|
t = utxo.pop() |
||||||
|
total_in += t["amount"] |
||||||
|
inputs.append({ "txid" : t["txid"], "vout" : t["vout"], "address" : t["address"] } ) |
||||||
|
if total_in < amount_needed: |
||||||
|
raise RuntimeError("Insufficient funds: need %d, have %d"%(amount_needed, total_in)) |
||||||
|
return (total_in, inputs) |
||||||
|
|
||||||
|
def make_change(from_node, amount_in, amount_out, fee): |
||||||
|
""" |
||||||
|
Create change output(s), return them |
||||||
|
""" |
||||||
|
outputs = {} |
||||||
|
amount = amount_out+fee |
||||||
|
change = amount_in - amount |
||||||
|
if change > amount*2: |
||||||
|
# Create an extra change output to break up big inputs |
||||||
|
change_address = from_node.getnewaddress() |
||||||
|
# Split change in two, being careful of rounding: |
||||||
|
outputs[change_address] = Decimal(change/2).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN) |
||||||
|
change = amount_in - amount - outputs[change_address] |
||||||
|
if change > 0: |
||||||
|
outputs[from_node.getnewaddress()] = change |
||||||
|
return outputs |
||||||
|
|
||||||
|
def send_zeropri_transaction(from_node, to_node, amount, fee): |
||||||
|
""" |
||||||
|
Create&broadcast a zero-priority transaction. |
||||||
|
Returns (txid, hex-encoded-txdata) |
||||||
|
Ensures transaction is zero-priority by first creating a send-to-self, |
||||||
|
then using its output |
||||||
|
""" |
||||||
|
|
||||||
|
# Create a send-to-self with confirmed inputs: |
||||||
|
self_address = from_node.getnewaddress() |
||||||
|
(total_in, inputs) = gather_inputs(from_node, amount+fee*2) |
||||||
|
outputs = make_change(from_node, total_in, amount+fee, fee) |
||||||
|
outputs[self_address] = float(amount+fee) |
||||||
|
|
||||||
|
self_rawtx = from_node.createrawtransaction(inputs, outputs) |
||||||
|
self_signresult = from_node.signrawtransaction(self_rawtx) |
||||||
|
self_txid = from_node.sendrawtransaction(self_signresult["hex"], True) |
||||||
|
|
||||||
|
vout = find_output(from_node, self_txid, amount+fee) |
||||||
|
# Now immediately spend the output to create a 1-input, 1-output |
||||||
|
# zero-priority transaction: |
||||||
|
inputs = [ { "txid" : self_txid, "vout" : vout } ] |
||||||
|
outputs = { to_node.getnewaddress() : float(amount) } |
||||||
|
|
||||||
|
rawtx = from_node.createrawtransaction(inputs, outputs) |
||||||
|
signresult = from_node.signrawtransaction(rawtx) |
||||||
|
txid = from_node.sendrawtransaction(signresult["hex"], True) |
||||||
|
|
||||||
|
return (txid, signresult["hex"]) |
||||||
|
|
||||||
|
def random_zeropri_transaction(nodes, amount, min_fee, fee_increment, fee_variants): |
||||||
|
""" |
||||||
|
Create a random zero-priority transaction. |
||||||
|
Returns (txid, hex-encoded-transaction-data, fee) |
||||||
|
""" |
||||||
|
from_node = random.choice(nodes) |
||||||
|
to_node = random.choice(nodes) |
||||||
|
fee = min_fee + fee_increment*random.randint(0,fee_variants) |
||||||
|
(txid, txhex) = send_zeropri_transaction(from_node, to_node, amount, fee) |
||||||
|
return (txid, txhex, fee) |
||||||
|
|
||||||
|
def random_transaction(nodes, amount, min_fee, fee_increment, fee_variants): |
||||||
|
""" |
||||||
|
Create a random transaction. |
||||||
|
Returns (txid, hex-encoded-transaction-data, fee) |
||||||
|
""" |
||||||
|
from_node = random.choice(nodes) |
||||||
|
to_node = random.choice(nodes) |
||||||
|
fee = min_fee + fee_increment*random.randint(0,fee_variants) |
||||||
|
|
||||||
|
(total_in, inputs) = gather_inputs(from_node, amount+fee) |
||||||
|
outputs = make_change(from_node, total_in, amount, fee) |
||||||
|
outputs[to_node.getnewaddress()] = float(amount) |
||||||
|
|
||||||
|
rawtx = from_node.createrawtransaction(inputs, outputs) |
||||||
|
signresult = from_node.signrawtransaction(rawtx) |
||||||
|
txid = from_node.sendrawtransaction(signresult["hex"], True) |
||||||
|
|
||||||
|
return (txid, signresult["hex"], fee) |
||||||
|
|
||||||
|
def assert_fee_amount(fee, tx_size, fee_per_kB): |
||||||
|
"""Assert the fee was in range""" |
||||||
|
target_fee = tx_size * fee_per_kB / 1000 |
||||||
|
if fee < target_fee: |
||||||
|
raise AssertionError("Fee of %s NAV too low! (Should be %s NAV)"%(str(fee), str(target_fee))) |
||||||
|
# allow the wallet's estimation to be at most 2 bytes off |
||||||
|
if fee > (tx_size + 2) * fee_per_kB / 1000: |
||||||
|
raise AssertionError("Fee of %s NAV too high! (Should be %s NAV)"%(str(fee), str(target_fee))) |
||||||
|
|
||||||
|
def assert_equal(thing1, thing2): |
||||||
|
if thing1 != thing2: |
||||||
|
raise AssertionError("%s != %s"%(str(thing1),str(thing2))) |
||||||
|
|
||||||
|
def assert_greater_than(thing1, thing2): |
||||||
|
if thing1 <= thing2: |
||||||
|
raise AssertionError("%s <= %s"%(str(thing1),str(thing2))) |
||||||
|
|
||||||
|
def assert_raises(exc, fun, *args, **kwds): |
||||||
|
try: |
||||||
|
fun(*args, **kwds) |
||||||
|
except exc: |
||||||
|
pass |
||||||
|
except Exception as e: |
||||||
|
raise AssertionError("Unexpected exception raised: "+type(e).__name__) |
||||||
|
else: |
||||||
|
raise AssertionError("No exception raised") |
||||||
|
|
||||||
|
def assert_is_hex_string(string): |
||||||
|
try: |
||||||
|
int(string, 16) |
||||||
|
except Exception as e: |
||||||
|
raise AssertionError( |
||||||
|
"Couldn't interpret %r as hexadecimal; raised: %s" % (string, e)) |
||||||
|
|
||||||
|
def assert_is_hash_string(string, length=64): |
||||||
|
if not isinstance(string, str): |
||||||
|
raise AssertionError("Expected a string, got type %r" % type(string)) |
||||||
|
elif length and len(string) != length: |
||||||
|
raise AssertionError( |
||||||
|
"String of length %d expected; got %d" % (length, len(string))) |
||||||
|
elif not re.match('[abcdef0-9]+$', string): |
||||||
|
raise AssertionError( |
||||||
|
"String %r contains invalid characters for a hash." % string) |
||||||
|
|
||||||
|
def assert_array_result(object_array, to_match, expected, should_not_find = False): |
||||||
|
""" |
||||||
|
Pass in array of JSON objects, a dictionary with key/value pairs |
||||||
|
to match against, and another dictionary with expected key/value |
||||||
|
pairs. |
||||||
|
If the should_not_find flag is true, to_match should not be found |
||||||
|
in object_array |
||||||
|
""" |
||||||
|
if should_not_find == True: |
||||||
|
assert_equal(expected, { }) |
||||||
|
num_matched = 0 |
||||||
|
for item in object_array: |
||||||
|
all_match = True |
||||||
|
for key,value in to_match.items(): |
||||||
|
if item[key] != value: |
||||||
|
all_match = False |
||||||
|
if not all_match: |
||||||
|
continue |
||||||
|
elif should_not_find == True: |
||||||
|
num_matched = num_matched+1 |
||||||
|
for key,value in expected.items(): |
||||||
|
if item[key] != value: |
||||||
|
raise AssertionError("%s : expected %s=%s"%(str(item), str(key), str(value))) |
||||||
|
num_matched = num_matched+1 |
||||||
|
if num_matched == 0 and should_not_find != True: |
||||||
|
raise AssertionError("No objects matched %s"%(str(to_match))) |
||||||
|
if num_matched > 0 and should_not_find == True: |
||||||
|
raise AssertionError("Objects were found %s"%(str(to_match))) |
||||||
|
|
||||||
|
def assert_raises_rpc_error(code, message, fun, *args, **kwds): |
||||||
|
"""Run an RPC and verify that a specific JSONRPC exception code and message is raised. |
||||||
|
Calls function `fun` with arguments `args` and `kwds`. Catches a JSONRPCException |
||||||
|
and verifies that the error code and message are as expected. Throws AssertionError if |
||||||
|
no JSONRPCException was raised or if the error code/message are not as expected. |
||||||
|
Args: |
||||||
|
code (int), optional: the error code returned by the RPC call (defined |
||||||
|
in src/rpc/protocol.h). Set to None if checking the error code is not required. |
||||||
|
message (string), optional: [a substring of] the error string returned by the |
||||||
|
RPC call. Set to None if checking the error string is not required. |
||||||
|
fun (function): the function to call. This should be the name of an RPC. |
||||||
|
args*: positional arguments for the function. |
||||||
|
kwds**: named arguments for the function. |
||||||
|
""" |
||||||
|
assert try_rpc(code, message, fun, *args, **kwds), "No exception raised" |
||||||
|
|
||||||
|
def try_rpc(code, message, fun, *args, **kwds): |
||||||
|
"""Tries to run an rpc command. |
||||||
|
Test against error code and message if the rpc fails. |
||||||
|
Returns whether a JSONRPCException was raised.""" |
||||||
|
try: |
||||||
|
fun(*args, **kwds) |
||||||
|
except JSONRPCException as e: |
||||||
|
# JSONRPCException was thrown as expected. Check the code and message values are correct. |
||||||
|
if (code is not None) and (code != e.error["code"]): |
||||||
|
raise AssertionError("Unexpected JSONRPC error code %i" % e.error["code"]) |
||||||
|
if (message is not None) and (message not in e.error['message']): |
||||||
|
raise AssertionError("Expected substring not found:" + e.error['message']) |
||||||
|
return True |
||||||
|
except Exception as e: |
||||||
|
raise AssertionError("Unexpected exception raised: " + type(e).__name__) |
||||||
|
else: |
||||||
|
return False |
||||||
|
|
||||||
|
def satoshi_round(amount): |
||||||
|
return Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN) |
||||||
|
|
||||||
|
# Helper to create at least "count" utxos |
||||||
|
# Pass in a fee that is sufficient for relay and mining new transactions. |
||||||
|
def create_confirmed_utxos(fee, node, count): |
||||||
|
node.generate(int(0.5*count)+101) |
||||||
|
utxos = node.listunspent() |
||||||
|
iterations = count - len(utxos) |
||||||
|
addr1 = node.getnewaddress() |
||||||
|
addr2 = node.getnewaddress() |
||||||
|
if iterations <= 0: |
||||||
|
return utxos |
||||||
|
for i in range(iterations): |
||||||
|
t = utxos.pop() |
||||||
|
inputs = [] |
||||||
|
inputs.append({ "txid" : t["txid"], "vout" : t["vout"]}) |
||||||
|
outputs = {} |
||||||
|
send_value = t['amount'] - fee |
||||||
|
outputs[addr1] = satoshi_round(send_value/2) |
||||||
|
outputs[addr2] = satoshi_round(send_value/2) |
||||||
|
raw_tx = node.createrawtransaction(inputs, outputs) |
||||||
|
signed_tx = node.signrawtransaction(raw_tx)["hex"] |
||||||
|
txid = node.sendrawtransaction(signed_tx) |
||||||
|
|
||||||
|
while (node.getmempoolinfo()['size'] > 0): |
||||||
|
node.generate(1) |
||||||
|
|
||||||
|
utxos = node.listunspent() |
||||||
|
assert(len(utxos) >= count) |
||||||
|
return utxos |
||||||
|
|
||||||
|
# Create large OP_RETURN txouts that can be appended to a transaction |
||||||
|
# to make it large (helper for constructing large transactions). |
||||||
|
def gen_return_txouts(): |
||||||
|
# Some pre-processing to create a bunch of OP_RETURN txouts to insert into transactions we create |
||||||
|
# So we have big transactions (and therefore can't fit very many into each block) |
||||||
|
# create one script_pubkey |
||||||
|
script_pubkey = "6a4d0200" #OP_RETURN OP_PUSH2 512 bytes |
||||||
|
for i in range (512): |
||||||
|
script_pubkey = script_pubkey + "01" |
||||||
|
# concatenate 128 txouts of above script_pubkey which we'll insert before the txout for change |
||||||
|
txouts = "81" |
||||||
|
for k in range(128): |
||||||
|
# add txout value |
||||||
|
txouts = txouts + "0000000000000000" |
||||||
|
# add length of script_pubkey |
||||||
|
txouts = txouts + "fd0402" |
||||||
|
# add script_pubkey |
||||||
|
txouts = txouts + script_pubkey |
||||||
|
return txouts |
||||||
|
|
||||||
|
def create_tx(node, coinbase, to_address, amount): |
||||||
|
inputs = [{ "txid" : coinbase, "vout" : 0}] |
||||||
|
outputs = { to_address : amount } |
||||||
|
rawtx = node.createrawtransaction(inputs, outputs) |
||||||
|
signresult = node.signrawtransaction(rawtx) |
||||||
|
assert_equal(signresult["complete"], True) |
||||||
|
return signresult["hex"] |
||||||
|
|
||||||
|
# Create a spend of each passed-in utxo, splicing in "txouts" to each raw |
||||||
|
# transaction to make it large. See gen_return_txouts() above. |
||||||
|
def create_lots_of_big_transactions(node, txouts, utxos, fee): |
||||||
|
addr = node.getnewaddress() |
||||||
|
txids = [] |
||||||
|
for i in range(len(utxos)): |
||||||
|
t = utxos.pop() |
||||||
|
inputs = [] |
||||||
|
inputs.append({ "txid" : t["txid"], "vout" : t["vout"]}) |
||||||
|
outputs = {} |
||||||
|
send_value = t['amount'] - fee |
||||||
|
outputs[addr] = satoshi_round(send_value) |
||||||
|
rawtx = node.createrawtransaction(inputs, outputs) |
||||||
|
newtx = rawtx[0:92] |
||||||
|
newtx = newtx + txouts |
||||||
|
newtx = newtx + rawtx[94:] |
||||||
|
signresult = node.signrawtransaction(newtx, None, None, "NONE") |
||||||
|
txid = node.sendrawtransaction(signresult["hex"], True) |
||||||
|
txids.append(txid) |
||||||
|
return txids |
||||||
|
|
||||||
|
def get_bip9_status(node, key): |
||||||
|
info = node.getblockchaininfo() |
||||||
|
return info['bip9_softforks'][key] |
||||||
|
|
||||||
|
|
||||||
|
def slow_gen(node, count, sleep = 0.1): |
||||||
|
total = count |
||||||
|
blocks = [] |
||||||
|
while total > 0: |
||||||
|
now = min(total, 10) |
||||||
|
blocks.extend(node.generate(now)) |
||||||
|
total -= now |
||||||
|
time.sleep(sleep) |
||||||
|
return blocks |
||||||
@ -0,0 +1,666 @@ |
|||||||
|
#!/usr/bin/env python |
||||||
|
# -*- coding: utf-8 -*- |
||||||
|
|
||||||
|
# Copyright (c) 2023 tecnovert |
||||||
|
# Distributed under the MIT software license, see the accompanying |
||||||
|
# file LICENSE or http://www.opensource.org/licenses/mit-license.php. |
||||||
|
|
||||||
|
from io import BytesIO |
||||||
|
from coincurve.keys import ( |
||||||
|
PublicKey, |
||||||
|
PrivateKey, |
||||||
|
) |
||||||
|
from .btc import BTCInterface, find_vout_for_address_from_txobj, findOutput |
||||||
|
from basicswap.chainparams import Coins |
||||||
|
from basicswap.interface.contrib.nav_test_framework.mininode import ( |
||||||
|
CTxIn, |
||||||
|
CTxOut, |
||||||
|
CBlock, |
||||||
|
COutPoint, |
||||||
|
CTransaction, |
||||||
|
CTxInWitness, |
||||||
|
FromHex, |
||||||
|
uint256_from_str, |
||||||
|
) |
||||||
|
from basicswap.util.address import ( |
||||||
|
decodeWif, |
||||||
|
pubkeyToAddress, |
||||||
|
encodeAddress, |
||||||
|
) |
||||||
|
from basicswap.util import ( |
||||||
|
i2b, i2h, |
||||||
|
ensure, |
||||||
|
) |
||||||
|
from basicswap.basicswap_util import ( |
||||||
|
getVoutByScriptPubKey, |
||||||
|
) |
||||||
|
|
||||||
|
from basicswap.interface.contrib.nav_test_framework.script import ( |
||||||
|
hash160, |
||||||
|
CScript, |
||||||
|
OP_0, |
||||||
|
OP_EQUAL, |
||||||
|
OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG, |
||||||
|
SIGHASH_ALL, |
||||||
|
SegwitVersion1SignatureHash, |
||||||
|
) |
||||||
|
from mnemonic import Mnemonic |
||||||
|
|
||||||
|
|
||||||
|
class NAVInterface(BTCInterface): |
||||||
|
@staticmethod |
||||||
|
def coin_type(): |
||||||
|
return Coins.NAV |
||||||
|
|
||||||
|
@staticmethod |
||||||
|
def txVersion() -> int: |
||||||
|
return 3 |
||||||
|
|
||||||
|
@staticmethod |
||||||
|
def txoType(): |
||||||
|
return CTxOut |
||||||
|
|
||||||
|
def use_p2shp2wsh(self) -> bool: |
||||||
|
# p2sh-p2wsh |
||||||
|
return True |
||||||
|
|
||||||
|
def seedToMnemonic(self, key): |
||||||
|
return Mnemonic('english').to_mnemonic(key) |
||||||
|
|
||||||
|
def initialiseWallet(self, key): |
||||||
|
# load with -importmnemonic= parameter |
||||||
|
pass |
||||||
|
|
||||||
|
def getWalletSeedID(self): |
||||||
|
return self.rpc_callback('getwalletinfo')['hdmasterkeyid'] |
||||||
|
|
||||||
|
def withdrawCoin(self, value, addr_to: str, subfee: bool): |
||||||
|
strdzeel = '' |
||||||
|
params = [addr_to, value, '', '', strdzeel, subfee] |
||||||
|
return self.rpc_callback('sendtoaddress', params) |
||||||
|
|
||||||
|
def getSpendableBalance(self) -> int: |
||||||
|
return self.make_int(self.rpc_callback('getwalletinfo')['balance']) |
||||||
|
|
||||||
|
def signTxWithWallet(self, tx: bytes) -> bytes: |
||||||
|
rv = self.rpc_callback('signrawtransaction', [tx.hex()]) |
||||||
|
|
||||||
|
return bytes.fromhex(rv['hex']) |
||||||
|
|
||||||
|
def checkExpectedSeed(self, key_hash: str): |
||||||
|
try: |
||||||
|
rv = self.rpc_callback('dumpmnemonic') |
||||||
|
entropy = Mnemonic('english').to_entropy(rv.split(' ')) |
||||||
|
|
||||||
|
entropy_hash = self.getAddressHashFromKey(entropy)[::-1].hex() |
||||||
|
self._have_checked_seed = True |
||||||
|
return entropy_hash == key_hash |
||||||
|
except Exception as e: |
||||||
|
self._log.warning('checkExpectedSeed failed: {}'.format(str(e))) |
||||||
|
return False |
||||||
|
|
||||||
|
def getScriptForP2PKH(self, pkh: bytes) -> bytearray: |
||||||
|
# Return P2PKH |
||||||
|
return CScript([OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG]) |
||||||
|
|
||||||
|
def getScriptForPubkeyHash(self, pkh: bytes) -> bytearray: |
||||||
|
# Return P2SH-p2wpkh |
||||||
|
|
||||||
|
script = CScript([OP_0, pkh]) |
||||||
|
script_hash = hash160(script) |
||||||
|
assert len(script_hash) == 20 |
||||||
|
|
||||||
|
return CScript([OP_HASH160, script_hash, OP_EQUAL]) |
||||||
|
|
||||||
|
def getInputScriptForPubkeyHash(self, pkh: bytes) -> bytearray: |
||||||
|
script = CScript([OP_0, pkh]) |
||||||
|
return bytes((len(script),)) + script |
||||||
|
|
||||||
|
def encodeSegwitAddress(self, pkh: bytes) -> str: |
||||||
|
# P2SH-p2wpkh |
||||||
|
script = CScript([OP_0, pkh]) |
||||||
|
script_hash = hash160(script) |
||||||
|
assert len(script_hash) == 20 |
||||||
|
return encodeAddress(bytes((self.chainparams_network()['script_address'],)) + script_hash) |
||||||
|
|
||||||
|
def encodeSegwitAddressScript(self, script: bytes) -> str: |
||||||
|
if len(script) == 23 and script[0] == OP_HASH160 and script[1] == 20 and script[22] == OP_EQUAL: |
||||||
|
script_hash = script[2:22] |
||||||
|
return encodeAddress(bytes((self.chainparams_network()['script_address'],)) + script_hash) |
||||||
|
raise ValueError('Unknown Script') |
||||||
|
|
||||||
|
def loadTx(self, tx_bytes: bytes) -> CTransaction: |
||||||
|
# Load tx from bytes to internal representation |
||||||
|
tx = CTransaction() |
||||||
|
tx.deserialize(BytesIO(tx_bytes)) |
||||||
|
return tx |
||||||
|
|
||||||
|
def signTx(self, key_bytes: bytes, tx_bytes: bytes, input_n: int, prevout_script, prevout_value: int): |
||||||
|
tx = self.loadTx(tx_bytes) |
||||||
|
sig_hash = SegwitVersion1SignatureHash(prevout_script, tx, input_n, SIGHASH_ALL, prevout_value) |
||||||
|
eck = PrivateKey(key_bytes) |
||||||
|
return eck.sign(sig_hash, hasher=None) + bytes((SIGHASH_ALL,)) |
||||||
|
|
||||||
|
def setTxSignature(self, tx_bytes: bytes, stack) -> bytes: |
||||||
|
tx = self.loadTx(tx_bytes) |
||||||
|
tx.wit.vtxinwit.clear() |
||||||
|
tx.wit.vtxinwit.append(CTxInWitness()) |
||||||
|
tx.wit.vtxinwit[0].scriptWitness.stack = stack |
||||||
|
return tx.serialize_with_witness() |
||||||
|
|
||||||
|
def verifyProofOfFunds(self, address, signature, extra_commit_bytes): |
||||||
|
self._log.warning('verifyProofOfFunds TODO') |
||||||
|
# TODO: Port scantxoutset or external lookup or read utxodb directly |
||||||
|
return 999999 * self.COIN() |
||||||
|
|
||||||
|
def createRawFundedTransaction(self, addr_to: str, amount: int, sub_fee: bool = False, lock_unspents: bool = True) -> str: |
||||||
|
txn = self.rpc_callback('createrawtransaction', [[], {addr_to: self.format_amount(amount)}]) |
||||||
|
fee_rate, fee_src = self.get_fee_rate(self._conf_target) |
||||||
|
self._log.debug(f'Fee rate: {fee_rate}, source: {fee_src}, block target: {self._conf_target}') |
||||||
|
if sub_fee: |
||||||
|
raise ValueError('Navcoin fundrawtransaction is missing the subtractFeeFromOutputs parameter') |
||||||
|
# options['subtractFeeFromOutputs'] = [0,] |
||||||
|
|
||||||
|
return self.fundTx(txn, fee_rate, lock_unspents) |
||||||
|
|
||||||
|
def isAddressMine(self, address: str, or_watch_only: bool = False) -> bool: |
||||||
|
addr_info = self.rpc_callback('validateaddress', [address]) |
||||||
|
if not or_watch_only: |
||||||
|
return addr_info['ismine'] |
||||||
|
return addr_info['ismine'] or addr_info['iswatchonly'] |
||||||
|
|
||||||
|
def createRawSignedTransaction(self, addr_to, amount) -> str: |
||||||
|
txn_funded = self.createRawFundedTransaction(addr_to, amount) |
||||||
|
return self.rpc_callback('signrawtransaction', [txn_funded])['hex'] |
||||||
|
|
||||||
|
def getBlockchainInfo(self): |
||||||
|
rv = self.rpc_callback('getblockchaininfo') |
||||||
|
synced = round(rv['verificationprogress'], 3) |
||||||
|
if synced >= 0.997: |
||||||
|
rv['verificationprogress'] = 1.0 |
||||||
|
return rv |
||||||
|
|
||||||
|
def encodeScriptDest(self, script_dest: bytes) -> str: |
||||||
|
script_hash = script_dest[2:-1] # Extract hash from script |
||||||
|
return self.sh_to_address(script_hash) |
||||||
|
|
||||||
|
def encode_p2wsh(self, script: bytes) -> str: |
||||||
|
return pubkeyToAddress(self.chainparams_network()['script_address'], script) |
||||||
|
|
||||||
|
def find_prevout_info(self, txn_hex: str, txn_script: bytes): |
||||||
|
txjs = self.rpc_callback('decoderawtransaction', [txn_hex]) |
||||||
|
n = getVoutByScriptPubKey(txjs, self.getScriptDest(txn_script).hex()) |
||||||
|
|
||||||
|
return { |
||||||
|
'txid': txjs['txid'], |
||||||
|
'vout': n, |
||||||
|
'scriptPubKey': txjs['vout'][n]['scriptPubKey']['hex'], |
||||||
|
'redeemScript': txn_script.hex(), |
||||||
|
'amount': txjs['vout'][n]['value'] |
||||||
|
} |
||||||
|
|
||||||
|
def getProofOfFunds(self, amount_for, extra_commit_bytes): |
||||||
|
# TODO: Lock unspent and use same output/s to fund bid |
||||||
|
unspent_addr = self.getUnspentsByAddr() |
||||||
|
|
||||||
|
sign_for_addr = None |
||||||
|
for addr, value in unspent_addr.items(): |
||||||
|
if value >= amount_for: |
||||||
|
sign_for_addr = addr |
||||||
|
break |
||||||
|
|
||||||
|
ensure(sign_for_addr is not None, 'Could not find address with enough funds for proof') |
||||||
|
|
||||||
|
self._log.debug('sign_for_addr %s', sign_for_addr) |
||||||
|
|
||||||
|
if self.using_segwit(): # TODO: Use isSegwitAddress when scantxoutset can use combo |
||||||
|
# 'Address does not refer to key' for non p2pkh |
||||||
|
addr_info = self.rpc_callback('validateaddress', [addr, ]) |
||||||
|
if 'isscript' in addr_info and addr_info['isscript'] and 'hex' in addr_info: |
||||||
|
pkh = bytes.fromhex(addr_info['hex'])[2:] |
||||||
|
sign_for_addr = self.pkh_to_address(pkh) |
||||||
|
self._log.debug('sign_for_addr converted %s', sign_for_addr) |
||||||
|
|
||||||
|
signature = self.rpc_callback('signmessage', [sign_for_addr, sign_for_addr + '_swap_proof_' + extra_commit_bytes.hex()]) |
||||||
|
|
||||||
|
return (sign_for_addr, signature) |
||||||
|
|
||||||
|
def getNewAddress(self, use_segwit: bool, label: str = 'swap_receive') -> str: |
||||||
|
address: str = self.rpc_callback('getnewaddress', [label,]) |
||||||
|
if use_segwit: |
||||||
|
return self.rpc_callback('addwitnessaddress', [address,]) |
||||||
|
return address |
||||||
|
|
||||||
|
def createRedeemTxn(self, prevout, output_addr: str, output_value: int, txn_script: bytes) -> str: |
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
prev_txid = uint256_from_str(bytes.fromhex(prevout['txid'])[::-1]) |
||||||
|
|
||||||
|
tx.vin.append(CTxIn(COutPoint(prev_txid, prevout['vout']), |
||||||
|
scriptSig=self.getScriptScriptSig(txn_script))) |
||||||
|
pkh = self.decodeAddress(output_addr) |
||||||
|
script = self.getScriptForPubkeyHash(pkh) |
||||||
|
tx.vout.append(self.txoType()(output_value, script)) |
||||||
|
tx.rehash() |
||||||
|
return tx.serialize().hex() |
||||||
|
|
||||||
|
def createRefundTxn(self, prevout, output_addr: str, output_value: int, locktime: int, sequence: int, txn_script: bytes) -> str: |
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
tx.nLockTime = locktime |
||||||
|
prev_txid = uint256_from_str(bytes.fromhex(prevout['txid'])[::-1]) |
||||||
|
tx.vin.append(CTxIn(COutPoint(prev_txid, prevout['vout']), |
||||||
|
nSequence=sequence, |
||||||
|
scriptSig=self.getScriptScriptSig(txn_script))) |
||||||
|
pkh = self.decodeAddress(output_addr) |
||||||
|
script = self.getScriptForPubkeyHash(pkh) |
||||||
|
tx.vout.append(self.txoType()(output_value, script)) |
||||||
|
tx.rehash() |
||||||
|
return tx.serialize().hex() |
||||||
|
|
||||||
|
def getTxSignature(self, tx_hex: str, prevout_data, key_wif: str) -> str: |
||||||
|
key = decodeWif(key_wif) |
||||||
|
redeem_script = bytes.fromhex(prevout_data['redeemScript']) |
||||||
|
sig = self.signTx(key, bytes.fromhex(tx_hex), 0, redeem_script, self.make_int(prevout_data['amount'])) |
||||||
|
|
||||||
|
return sig.hex() |
||||||
|
|
||||||
|
def verifyTxSig(self, tx_bytes: bytes, sig: bytes, K: bytes, input_n: int, prevout_script: bytes, prevout_value: int) -> bool: |
||||||
|
tx = self.loadTx(tx_bytes) |
||||||
|
sig_hash = SegwitVersion1SignatureHash(prevout_script, tx, input_n, SIGHASH_ALL, prevout_value) |
||||||
|
|
||||||
|
pubkey = PublicKey(K) |
||||||
|
return pubkey.verify(sig[: -1], sig_hash, hasher=None) # Pop the hashtype byte |
||||||
|
|
||||||
|
def verifyRawTransaction(self, tx_hex: str, prevouts): |
||||||
|
# Only checks signature |
||||||
|
# verifyrawtransaction |
||||||
|
self._log.warning('NAV verifyRawTransaction only checks signature') |
||||||
|
inputs_valid: bool = False |
||||||
|
validscripts: int = 0 |
||||||
|
|
||||||
|
tx_bytes = bytes.fromhex(tx_hex) |
||||||
|
tx = self.loadTx(bytes.fromhex(tx_hex)) |
||||||
|
|
||||||
|
signature = tx.wit.vtxinwit[0].scriptWitness.stack[0] |
||||||
|
pubkey = tx.wit.vtxinwit[0].scriptWitness.stack[1] |
||||||
|
|
||||||
|
input_n: int = 0 |
||||||
|
prevout_data = prevouts[input_n] |
||||||
|
redeem_script = bytes.fromhex(prevout_data['redeemScript']) |
||||||
|
prevout_value = self.make_int(prevout_data['amount']) |
||||||
|
|
||||||
|
if self.verifyTxSig(tx_bytes, signature, pubkey, input_n, redeem_script, prevout_value): |
||||||
|
validscripts += 1 |
||||||
|
|
||||||
|
# TODO: validate inputs |
||||||
|
inputs_valid = True |
||||||
|
|
||||||
|
return { |
||||||
|
'inputs_valid': inputs_valid, |
||||||
|
'validscripts': validscripts, |
||||||
|
} |
||||||
|
|
||||||
|
def getHTLCSpendTxVSize(self, redeem: bool = True) -> int: |
||||||
|
tx_vsize = 5 # Add a few bytes, sequence in script takes variable amount of bytes |
||||||
|
|
||||||
|
tx_vsize += 184 if redeem else 187 |
||||||
|
return tx_vsize |
||||||
|
|
||||||
|
def getTxid(self, tx) -> bytes: |
||||||
|
if isinstance(tx, str): |
||||||
|
tx = bytes.fromhex(tx) |
||||||
|
if isinstance(tx, bytes): |
||||||
|
tx = self.loadTx(tx) |
||||||
|
tx.rehash() |
||||||
|
return i2b(tx.sha256) |
||||||
|
|
||||||
|
def rescanBlockchainForAddress(self, height_start: int, addr_find: str): |
||||||
|
# Very ugly workaround for missing `rescanblockchain` rpc command |
||||||
|
|
||||||
|
chain_blocks: int = self.getChainHeight() |
||||||
|
|
||||||
|
current_height: int = chain_blocks |
||||||
|
block_hash = self.rpc_callback('getblockhash', [current_height]) |
||||||
|
|
||||||
|
script_hash: bytes = self.decodeAddress(addr_find) |
||||||
|
find_scriptPubKey = self.getDestForScriptHash(script_hash) |
||||||
|
|
||||||
|
while current_height > height_start: |
||||||
|
block_hash = self.rpc_callback('getblockhash', [current_height]) |
||||||
|
|
||||||
|
block = self.rpc_callback('getblock', [block_hash, False]) |
||||||
|
decoded_block = CBlock() |
||||||
|
decoded_block = FromHex(decoded_block, block) |
||||||
|
for tx in decoded_block.vtx: |
||||||
|
for txo in tx.vout: |
||||||
|
if txo.scriptPubKey == find_scriptPubKey: |
||||||
|
tx.rehash() |
||||||
|
txid = i2b(tx.sha256) |
||||||
|
self._log.info('Found output to addr: {} in tx {} in block {}'.format(addr_find, txid.hex(), block_hash)) |
||||||
|
self._log.info('rescanblockchain hack invalidateblock {}'.format(block_hash)) |
||||||
|
self.rpc_callback('invalidateblock', [block_hash]) |
||||||
|
self.rpc_callback('reconsiderblock', [block_hash]) |
||||||
|
return |
||||||
|
current_height -= 1 |
||||||
|
|
||||||
|
def getLockTxHeight(self, txid, dest_address, bid_amount, rescan_from, find_index: bool = False): |
||||||
|
# Add watchonly address and rescan if required |
||||||
|
|
||||||
|
if not self.isAddressMine(dest_address, or_watch_only=True): |
||||||
|
self.importWatchOnlyAddress(dest_address, 'bid') |
||||||
|
self._log.info('Imported watch-only addr: {}'.format(dest_address)) |
||||||
|
# Importing triggers a rescan |
||||||
|
self._log.info('Rescanning {} chain from height: {}'.format(self.coin_name(), rescan_from)) |
||||||
|
self.rescanBlockchainForAddress(rescan_from, dest_address) |
||||||
|
|
||||||
|
return_txid = True if txid is None else False |
||||||
|
if txid is None: |
||||||
|
txns = self.rpc_callback('listunspent', [0, 9999999, [dest_address, ]]) |
||||||
|
|
||||||
|
for tx in txns: |
||||||
|
if self.make_int(tx['amount']) == bid_amount: |
||||||
|
txid = bytes.fromhex(tx['txid']) |
||||||
|
break |
||||||
|
|
||||||
|
if txid is None: |
||||||
|
return None |
||||||
|
|
||||||
|
try: |
||||||
|
tx = self.rpc_callback('gettransaction', [txid.hex()]) |
||||||
|
|
||||||
|
block_height = 0 |
||||||
|
if 'blockhash' in tx: |
||||||
|
block_header = self.rpc_callback('getblockheader', [tx['blockhash']]) |
||||||
|
block_height = block_header['height'] |
||||||
|
|
||||||
|
rv = { |
||||||
|
'depth': 0 if 'confirmations' not in tx else tx['confirmations'], |
||||||
|
'height': block_height} |
||||||
|
|
||||||
|
except Exception as e: |
||||||
|
self._log.debug('getLockTxHeight gettransaction failed: %s, %s', txid.hex(), str(e)) |
||||||
|
return None |
||||||
|
|
||||||
|
if find_index: |
||||||
|
tx_obj = self.rpc_callback('decoderawtransaction', [tx['hex']]) |
||||||
|
rv['index'] = find_vout_for_address_from_txobj(tx_obj, dest_address) |
||||||
|
|
||||||
|
if return_txid: |
||||||
|
rv['txid'] = txid.hex() |
||||||
|
|
||||||
|
return rv |
||||||
|
|
||||||
|
def getBlockWithTxns(self, block_hash): |
||||||
|
# TODO: Bypass decoderawtransaction and getblockheader |
||||||
|
block = self.rpc_callback('getblock', [block_hash, False]) |
||||||
|
block_header = self.rpc_callback('getblockheader', [block_hash]) |
||||||
|
decoded_block = CBlock() |
||||||
|
decoded_block = FromHex(decoded_block, block) |
||||||
|
|
||||||
|
tx_rv = [] |
||||||
|
for tx in decoded_block.vtx: |
||||||
|
tx_hex = tx.serialize_with_witness().hex() |
||||||
|
tx_dec = self.rpc_callback('decoderawtransaction', [tx_hex]) |
||||||
|
if 'hex' not in tx_dec: |
||||||
|
tx_dec['hex'] = tx_hex |
||||||
|
|
||||||
|
tx_rv.append(tx_dec) |
||||||
|
|
||||||
|
block_rv = { |
||||||
|
'hash': block_hash, |
||||||
|
'tx': tx_rv, |
||||||
|
'confirmations': block_header['confirmations'], |
||||||
|
'height': block_header['height'], |
||||||
|
'version': block_header['version'], |
||||||
|
'merkleroot': block_header['merkleroot'], |
||||||
|
} |
||||||
|
|
||||||
|
return block_rv |
||||||
|
|
||||||
|
def getScriptScriptSig(self, script: bytes) -> bytearray: |
||||||
|
return self.getP2SHP2WSHScriptSig(script) |
||||||
|
|
||||||
|
def getScriptDest(self, script): |
||||||
|
return self.getP2SHP2WSHDest(script) |
||||||
|
|
||||||
|
def getDestForScriptHash(self, script_hash): |
||||||
|
assert len(script_hash) == 20 |
||||||
|
return CScript([OP_HASH160, script_hash, OP_EQUAL]) |
||||||
|
|
||||||
|
def pubkey_to_segwit_address(self, pk: bytes) -> str: |
||||||
|
pkh = hash160(pk) |
||||||
|
script_out = self.getScriptForPubkeyHash(pkh) |
||||||
|
return self.encodeSegwitAddressScript(script_out) |
||||||
|
|
||||||
|
def createBLockTx(self, Kbs: bytes, output_amount: int, vkbv=None) -> bytes: |
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
script_pk = self.getPkDest(Kbs) |
||||||
|
tx.vout.append(self.txoType()(output_amount, script_pk)) |
||||||
|
return tx.serialize() |
||||||
|
|
||||||
|
def spendBLockTx(self, chain_b_lock_txid: bytes, address_to: str, kbv: bytes, kbs: bytes, cb_swap_value: int, b_fee: int, restore_height: int) -> bytes: |
||||||
|
self._log.info('spendBLockTx %s:\n', chain_b_lock_txid.hex()) |
||||||
|
wtx = self.rpc_callback('gettransaction', [chain_b_lock_txid.hex(), ]) |
||||||
|
lock_tx = self.loadTx(bytes.fromhex(wtx['hex'])) |
||||||
|
|
||||||
|
Kbs = self.getPubkey(kbs) |
||||||
|
script_pk = self.getPkDest(Kbs) |
||||||
|
locked_n = findOutput(lock_tx, script_pk) |
||||||
|
ensure(locked_n is not None, 'Output not found in tx') |
||||||
|
pkh_to = self.decodeAddress(address_to) |
||||||
|
|
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
|
||||||
|
chain_b_lock_txid_int = uint256_from_str(chain_b_lock_txid[::-1]) |
||||||
|
|
||||||
|
script_sig = self.getInputScriptForPubkeyHash(self.getPubkeyHash(Kbs)) |
||||||
|
|
||||||
|
tx.vin.append(CTxIn(COutPoint(chain_b_lock_txid_int, locked_n), |
||||||
|
nSequence=0, |
||||||
|
scriptSig=script_sig)) |
||||||
|
tx.vout.append(self.txoType()(cb_swap_value, self.getScriptForPubkeyHash(pkh_to))) |
||||||
|
|
||||||
|
pay_fee = self.getBLockSpendTxFee(tx, b_fee) |
||||||
|
tx.vout[0].nValue = cb_swap_value - pay_fee |
||||||
|
|
||||||
|
b_lock_spend_tx = tx.serialize() |
||||||
|
b_lock_spend_tx = self.signTxWithKey(b_lock_spend_tx, kbs, cb_swap_value) |
||||||
|
|
||||||
|
return bytes.fromhex(self.publishTx(b_lock_spend_tx)) |
||||||
|
|
||||||
|
def signTxWithKey(self, tx: bytes, key: bytes, prev_amount: int) -> bytes: |
||||||
|
Key = self.getPubkey(key) |
||||||
|
pkh = self.getPubkeyHash(Key) |
||||||
|
script = self.getScriptForP2PKH(pkh) |
||||||
|
|
||||||
|
sig = self.signTx(key, tx, 0, script, prev_amount) |
||||||
|
|
||||||
|
stack = [ |
||||||
|
sig, |
||||||
|
Key, |
||||||
|
] |
||||||
|
return self.setTxSignature(tx, stack) |
||||||
|
|
||||||
|
def findTxnByHash(self, txid_hex: str): |
||||||
|
# Only works for wallet txns |
||||||
|
try: |
||||||
|
rv = self.rpc_callback('gettransaction', [txid_hex]) |
||||||
|
except Exception as ex: |
||||||
|
self._log.debug('findTxnByHash getrawtransaction failed: {}'.format(txid_hex)) |
||||||
|
return None |
||||||
|
if 'confirmations' in rv and rv['confirmations'] >= self.blocks_confirmed: |
||||||
|
block_height = self.getBlockHeader(rv['blockhash'])['height'] |
||||||
|
return {'txid': txid_hex, 'amount': 0, 'height': block_height} |
||||||
|
return None |
||||||
|
|
||||||
|
def createSCLockTx(self, value: int, script: bytearray, vkbv: bytes = None) -> bytes: |
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
tx.vout.append(self.txoType()(value, self.getScriptDest(script))) |
||||||
|
|
||||||
|
return tx.serialize() |
||||||
|
|
||||||
|
def fundTx(self, tx, feerate, lock_unspents: bool = True): |
||||||
|
feerate_str = self.format_amount(feerate) |
||||||
|
# TODO: unlock unspents if bid cancelled |
||||||
|
options = { |
||||||
|
'lockUnspents': lock_unspents, |
||||||
|
'feeRate': feerate_str, |
||||||
|
} |
||||||
|
rv = self.rpc_callback('fundrawtransaction', [tx.hex(), options]) |
||||||
|
|
||||||
|
# Sign transaction then strip witness data to fill scriptsig |
||||||
|
rv = self.rpc_callback('signrawtransaction', [rv['hex']]) |
||||||
|
|
||||||
|
tx_signed = self.loadTx(bytes.fromhex(rv['hex'])) |
||||||
|
if len(tx_signed.vin) != len(tx_signed.wit.vtxinwit): |
||||||
|
raise ValueError('txn has non segwit input') |
||||||
|
for witness_data in tx_signed.wit.vtxinwit: |
||||||
|
if len(witness_data.scriptWitness.stack) < 2: |
||||||
|
raise ValueError('txn has non segwit input') |
||||||
|
|
||||||
|
return tx_signed.serialize_without_witness() |
||||||
|
|
||||||
|
def fundSCLockTx(self, tx_bytes: bytes, feerate, vkbv=None): |
||||||
|
tx_funded = self.fundTx(tx_bytes, feerate) |
||||||
|
return tx_funded |
||||||
|
|
||||||
|
def createSCLockRefundTx(self, tx_lock_bytes, script_lock, Kal, Kaf, lock1_value, csv_val, tx_fee_rate, vkbv=None): |
||||||
|
tx_lock = CTransaction() |
||||||
|
tx_lock = self.loadTx(tx_lock_bytes) |
||||||
|
|
||||||
|
output_script = self.getScriptDest(script_lock) |
||||||
|
locked_n = findOutput(tx_lock, output_script) |
||||||
|
ensure(locked_n is not None, 'Output not found in tx') |
||||||
|
locked_coin = tx_lock.vout[locked_n].nValue |
||||||
|
|
||||||
|
tx_lock.rehash() |
||||||
|
tx_lock_id_int = tx_lock.sha256 |
||||||
|
|
||||||
|
refund_script = self.genScriptLockRefundTxScript(Kal, Kaf, csv_val) |
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
tx.vin.append(CTxIn(COutPoint(tx_lock_id_int, locked_n), |
||||||
|
nSequence=lock1_value, |
||||||
|
scriptSig=self.getScriptScriptSig(script_lock))) |
||||||
|
tx.vout.append(self.txoType()(locked_coin, self.getScriptDest(refund_script))) |
||||||
|
|
||||||
|
dummy_witness_stack = self.getScriptLockTxDummyWitness(script_lock) |
||||||
|
witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack) |
||||||
|
vsize = self.getTxVSize(tx, add_witness_bytes=witness_bytes) |
||||||
|
pay_fee = round(tx_fee_rate * vsize / 1000) |
||||||
|
tx.vout[0].nValue = locked_coin - pay_fee |
||||||
|
|
||||||
|
tx.rehash() |
||||||
|
self._log.info('createSCLockRefundTx %s:\n fee_rate, vsize, fee: %ld, %ld, %ld.', |
||||||
|
i2h(tx.sha256), tx_fee_rate, vsize, pay_fee) |
||||||
|
|
||||||
|
return tx.serialize(), refund_script, tx.vout[0].nValue |
||||||
|
|
||||||
|
def createSCLockRefundSpendTx(self, tx_lock_refund_bytes, script_lock_refund, pkh_refund_to, tx_fee_rate, vkbv=None): |
||||||
|
# Returns the coinA locked coin to the leader |
||||||
|
# The follower will sign the multisig path with a signature encumbered by the leader's coinB spend pubkey |
||||||
|
# If the leader publishes the decrypted signature the leader's coinB spend privatekey will be revealed to the follower |
||||||
|
|
||||||
|
tx_lock_refund = self.loadTx(tx_lock_refund_bytes) |
||||||
|
|
||||||
|
output_script = self.getScriptDest(script_lock_refund) |
||||||
|
locked_n = findOutput(tx_lock_refund, output_script) |
||||||
|
ensure(locked_n is not None, 'Output not found in tx') |
||||||
|
locked_coin = tx_lock_refund.vout[locked_n].nValue |
||||||
|
|
||||||
|
tx_lock_refund.rehash() |
||||||
|
tx_lock_refund_hash_int = tx_lock_refund.sha256 |
||||||
|
|
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
tx.vin.append(CTxIn(COutPoint(tx_lock_refund_hash_int, locked_n), |
||||||
|
nSequence=0, |
||||||
|
scriptSig=self.getScriptScriptSig(script_lock_refund))) |
||||||
|
|
||||||
|
tx.vout.append(self.txoType()(locked_coin, self.getScriptForPubkeyHash(pkh_refund_to))) |
||||||
|
|
||||||
|
dummy_witness_stack = self.getScriptLockRefundSpendTxDummyWitness(script_lock_refund) |
||||||
|
witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack) |
||||||
|
vsize = self.getTxVSize(tx, add_witness_bytes=witness_bytes) |
||||||
|
pay_fee = round(tx_fee_rate * vsize / 1000) |
||||||
|
tx.vout[0].nValue = locked_coin - pay_fee |
||||||
|
|
||||||
|
tx.rehash() |
||||||
|
self._log.info('createSCLockRefundSpendTx %s:\n fee_rate, vsize, fee: %ld, %ld, %ld.', |
||||||
|
i2h(tx.sha256), tx_fee_rate, vsize, pay_fee) |
||||||
|
|
||||||
|
return tx.serialize() |
||||||
|
|
||||||
|
def createSCLockRefundSpendToFTx(self, tx_lock_refund_bytes, script_lock_refund, pkh_dest, tx_fee_rate, vkbv=None): |
||||||
|
# lock refund swipe tx |
||||||
|
# Sends the coinA locked coin to the follower |
||||||
|
|
||||||
|
tx_lock_refund = self.loadTx(tx_lock_refund_bytes) |
||||||
|
|
||||||
|
output_script = self.getScriptDest(script_lock_refund) |
||||||
|
locked_n = findOutput(tx_lock_refund, output_script) |
||||||
|
ensure(locked_n is not None, 'Output not found in tx') |
||||||
|
locked_coin = tx_lock_refund.vout[locked_n].nValue |
||||||
|
|
||||||
|
A, B, lock2_value, C = self.extractScriptLockRefundScriptValues(script_lock_refund) |
||||||
|
|
||||||
|
tx_lock_refund.rehash() |
||||||
|
tx_lock_refund_hash_int = tx_lock_refund.sha256 |
||||||
|
|
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
tx.vin.append(CTxIn(COutPoint(tx_lock_refund_hash_int, locked_n), |
||||||
|
nSequence=lock2_value, |
||||||
|
scriptSig=self.getScriptScriptSig(script_lock_refund))) |
||||||
|
|
||||||
|
tx.vout.append(self.txoType()(locked_coin, self.getScriptForPubkeyHash(pkh_dest))) |
||||||
|
|
||||||
|
dummy_witness_stack = self.getScriptLockRefundSwipeTxDummyWitness(script_lock_refund) |
||||||
|
witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack) |
||||||
|
vsize = self.getTxVSize(tx, add_witness_bytes=witness_bytes) |
||||||
|
pay_fee = round(tx_fee_rate * vsize / 1000) |
||||||
|
tx.vout[0].nValue = locked_coin - pay_fee |
||||||
|
|
||||||
|
tx.rehash() |
||||||
|
self._log.info('createSCLockRefundSpendToFTx %s:\n fee_rate, vsize, fee: %ld, %ld, %ld.', |
||||||
|
i2h(tx.sha256), tx_fee_rate, vsize, pay_fee) |
||||||
|
|
||||||
|
return tx.serialize() |
||||||
|
|
||||||
|
def createSCLockSpendTx(self, tx_lock_bytes, script_lock, pkh_dest, tx_fee_rate, vkbv=None, fee_info={}): |
||||||
|
tx_lock = self.loadTx(tx_lock_bytes) |
||||||
|
output_script = self.getScriptDest(script_lock) |
||||||
|
locked_n = findOutput(tx_lock, output_script) |
||||||
|
ensure(locked_n is not None, 'Output not found in tx') |
||||||
|
locked_coin = tx_lock.vout[locked_n].nValue |
||||||
|
|
||||||
|
tx_lock.rehash() |
||||||
|
tx_lock_id_int = tx_lock.sha256 |
||||||
|
|
||||||
|
tx = CTransaction() |
||||||
|
tx.nVersion = self.txVersion() |
||||||
|
tx.vin.append(CTxIn(COutPoint(tx_lock_id_int, locked_n), |
||||||
|
scriptSig=self.getScriptScriptSig(script_lock))) |
||||||
|
|
||||||
|
tx.vout.append(self.txoType()(locked_coin, self.getScriptForPubkeyHash(pkh_dest))) |
||||||
|
|
||||||
|
dummy_witness_stack = self.getScriptLockTxDummyWitness(script_lock) |
||||||
|
witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack) |
||||||
|
vsize = self.getTxVSize(tx, add_witness_bytes=witness_bytes) |
||||||
|
pay_fee = round(tx_fee_rate * vsize / 1000) |
||||||
|
tx.vout[0].nValue = locked_coin - pay_fee |
||||||
|
|
||||||
|
fee_info['fee_paid'] = pay_fee |
||||||
|
fee_info['rate_used'] = tx_fee_rate |
||||||
|
fee_info['witness_bytes'] = witness_bytes |
||||||
|
fee_info['vsize'] = vsize |
||||||
|
|
||||||
|
tx.rehash() |
||||||
|
self._log.info('createSCLockSpendTx %s:\n fee_rate, vsize, fee: %ld, %ld, %ld.', |
||||||
|
i2h(tx.sha256), tx_fee_rate, vsize, pay_fee) |
||||||
|
|
||||||
|
return tx.serialize() |
||||||
@ -0,0 +1,40 @@ |
|||||||
|
-----BEGIN PGP PUBLIC KEY BLOCK----- |
||||||
|
xsDNBF/8KgoBDADpq1pIJh2u7J6eX1u8awKFA/k0M826KejUFIMY/B25MlYaBaQm |
||||||
|
DMy2aCX9NuLCXtnA+Ys5UGlHb70KrsGLmlvA6Jk+nQZhjCM9RXTJtbMOrq84uTYc |
||||||
|
zRgWBfAkMU+HIj2svkdjrmDdCjdbip6myBbketgg9UP09GA2TxdLweghDwNjjz/a |
||||||
|
mVr2eaIoYWq13OFY7qoe8eKXQO0yGUv/T1abtJPiRFWpTwU4M7a8BqG2aFlJtzT2 |
||||||
|
WGDWn1pFkGEQMJqf+TKugRtDwoCv/TPJzATlCD9gzPUf3Xpbhv+f6Nj08WewBwhv |
||||||
|
tqdpVFPTkp4xQP5QgN+JsplfQcEgWNczIYGNrna0RG3KjL4a+mHUGFi14NwFioIa |
||||||
|
l4aqfBwbEOU5M+wLWfTsTAch7Pi42UeYEVpbEFZKQxxP3NeTere6sdwPJZg193nF |
||||||
|
cb/rjnvuPUlGJlZ+TJbGptlkjkH/mNRDB04iTR8XbSHdYgo+rKo0EDQoxkRTeTWw |
||||||
|
d1vGFOH9keg8Xq0AEQEAAc0kTmF2Q29pbiBDb3JlIDxidWlsZGVyQG5hdi5jb21t |
||||||
|
dW5pdHk+wsEUBBMBCgA+FiEEG/m1G67VG6CzoXTuJ4ImK/bn+tsFAl/8KgoCGwMF |
||||||
|
CQPCZwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQJ4ImK/bn+ttpxQv6AyWV |
||||||
|
2mKyaWWxjsZTVBt0wJeajT+CaNZ0jU/zvEUOnpsr0/r3mbVsyyxWNRUdIcfceYrB |
||||||
|
729x8B15GUE1RwpbRJwoKT5WjGeFd/sHkA+j6PRVg7x3pyJPzLYOB61rJsPTAOOM |
||||||
|
06og0Kj+qbzIlcwDQdCgxObGuoHGXQvTFsxrOYiGRca4x3qHbIYlNEemgO41RHu+ |
||||||
|
zZCmHwfPocIljr6/FMHOuZQ7zbdRqXNmZtIBOYhjhEK7qypKEQwYXoUNJBkzdfHl |
||||||
|
H8Mz/rSQ68jBcJ6fjXIs2XfUZgUaJAH/Xar9/52iApLr2AyBzHaXIGy+CUUWa+kR |
||||||
|
Tpo6OqEkk92O2mNGwTx4I1T6ZED4ABkGWdKZS0rU7MlcNSe000pV6IQPrPoDw9CU |
||||||
|
2PkJCyqZe1QqTdLtlHLoSlnLhLAd3vWPmw+T0MfMMSyuVMvqgC5vuCRJKDFs//uE |
||||||
|
LuP58CiC+DmNyLFMCgjqv3GKsaDag21gNp8IRDnmgrJn/UrRRwEOMcDUYLaKzsDN |
||||||
|
BF/8KgoBDADjAlvNASpQbzEQVOIUaJxXRP+09IvVavotS40LqOjvPuDWyOnA9+AP |
||||||
|
VOrmFo/+HndicMjQzasXnkc249uiYiLyshlyrme6ebbMp+4aDcSxQRfx2+oXLR1l |
||||||
|
0oBrchMiAJ+6xe0N6Itc6EhjAsPwG2IGfsFSmg9YYsm5NjHnujyvcQwcGG0OUBsy |
||||||
|
ydJWtL5AU1z3H5fegN6DKFaUW/IMcxNN6el8NRZkHLwNh+JLyulHWKYDs/1YJ5sY |
||||||
|
sknCvnicPAOpLqgdGopdu9ORnvOZ5wsJq8IFP6SBjdSjFj71eXam5dyWfMvMew1v |
||||||
|
IVkBHi4y/G1J0Rlzi2f8j38htGa2H9A4eG4WUDO/uDJ/g76sWTAVPnWNNG3BQLgN |
||||||
|
m2LDVNszGJNBTwFYlzEHrPipEA0foePHOLXc24o0/LZZYunP+zNvJiqqLEYCpvK/ |
||||||
|
nU7HozvHJvV8r+b/FK/vDLQbmp4HvvSL5ho/Dwn+yWU+Z+DPM+qIgukn4JrUUuZK |
||||||
|
c553H1U2LtsAEQEAAcLA/AQYAQoAJhYhBBv5tRuu1Rugs6F07ieCJiv25/rbBQJf |
||||||
|
/CoKAhsMBQkDwmcAAAoJECeCJiv25/rbN2gMAL28b3ou3c9aV99F8fEniZLsR2t7 |
||||||
|
EcZ93kBd9ozgeVnabSDsaRvlQ1uJDabemhcLyRY5fCCBAAXGCZ6jtxicOgt0cb+S |
||||||
|
MHcrM7EUHLfxguM296V633svaFSUCwk3kBLMv9ukIrWu3oflE9MUyM/J92A0/TP/ |
||||||
|
PgBzD31xbiEEcSEqKt/CBP/pQbTSEgIa+JjGKYVPrN+n8kitY/Vu3yUNpATSH3j/ |
||||||
|
0cl/f5IXhg4uwqCzmopkU8lH/WGP90kIvG6ZwCstNJ4GN9sKRYKN++19PdDUmi++ |
||||||
|
z9FC0cu6GgSuWIWd2CyhGhOqMkFlwOnN5U5svH+wFlBK5+z6MgEkPCR6L2XPMonE |
||||||
|
bd6JCKuw7SUHN4pUCZ2lnEStjiGM/cziuZ01U1TesH4W6CdOSl9+/sI4wwO//Qj/ |
||||||
|
/QYSjNwXNexgFA7pX90boRjQl1LNMocHVaYriGzw7n9fKJPwYI5oUam5By3sYmTT |
||||||
|
i0WBmStFWb3bvqfkdjbe86g7ilbbLIoAlUS03w== |
||||||
|
=Y9TC |
||||||
|
-----END PGP PUBLIC KEY BLOCK----- |
||||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in new issue